1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Edit GetTrace api.

Browse Source
This commit is contained in:
sdk-team
2021-03-18 12:30:09 +00:00
parent 99896a3333
commit edf8a946ea
41 changed files with 1988 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
arms/CMakeLists.txt
View File

@@ -31,12 +31,16 @@ set(arms_public_header_model
include/alibabacloud/arms/model/CheckDataConsistencyResult.h
include/alibabacloud/arms/model/CheckServiceLinkedRoleForDeletingRequest.h
include/alibabacloud/arms/model/CheckServiceLinkedRoleForDeletingResult.h
include/alibabacloud/arms/model/CheckServiceStatusRequest.h
include/alibabacloud/arms/model/CheckServiceStatusResult.h
include/alibabacloud/arms/model/ConfigAppRequest.h
include/alibabacloud/arms/model/ConfigAppResult.h
include/alibabacloud/arms/model/CreateAlertContactRequest.h
include/alibabacloud/arms/model/CreateAlertContactResult.h
include/alibabacloud/arms/model/CreateAlertContactGroupRequest.h
include/alibabacloud/arms/model/CreateAlertContactGroupResult.h
include/alibabacloud/arms/model/CreateDispatchRuleRequest.h
include/alibabacloud/arms/model/CreateDispatchRuleResult.h
include/alibabacloud/arms/model/CreateRetcodeAppRequest.h
include/alibabacloud/arms/model/CreateRetcodeAppResult.h
include/alibabacloud/arms/model/CreateWehookRequest.h
@@ -47,6 +51,8 @@ set(arms_public_header_model
include/alibabacloud/arms/model/DeleteAlertContactGroupResult.h
include/alibabacloud/arms/model/DeleteAlertRulesRequest.h
include/alibabacloud/arms/model/DeleteAlertRulesResult.h
include/alibabacloud/arms/model/DeleteDispatchRuleRequest.h
include/alibabacloud/arms/model/DeleteDispatchRuleResult.h
include/alibabacloud/arms/model/DeleteRetcodeAppRequest.h
include/alibabacloud/arms/model/DeleteRetcodeAppResult.h
include/alibabacloud/arms/model/DeleteScenarioRequest.h
@@ -91,16 +97,22 @@ set(arms_public_header_model
include/alibabacloud/arms/model/ListClusterFromGrafanaResult.h
include/alibabacloud/arms/model/ListDashboardsRequest.h
include/alibabacloud/arms/model/ListDashboardsResult.h
include/alibabacloud/arms/model/ListDispatchRuleRequest.h
include/alibabacloud/arms/model/ListDispatchRuleResult.h
include/alibabacloud/arms/model/ListPromClustersRequest.h
include/alibabacloud/arms/model/ListPromClustersResult.h
include/alibabacloud/arms/model/ListRetcodeAppsRequest.h
include/alibabacloud/arms/model/ListRetcodeAppsResult.h
include/alibabacloud/arms/model/ListScenarioRequest.h
include/alibabacloud/arms/model/ListScenarioResult.h
include/alibabacloud/arms/model/ListServerlessTopNAppsRequest.h
include/alibabacloud/arms/model/ListServerlessTopNAppsResult.h
include/alibabacloud/arms/model/ListTraceAppsRequest.h
include/alibabacloud/arms/model/ListTraceAppsResult.h
include/alibabacloud/arms/model/OpenArmsServiceRequest.h
include/alibabacloud/arms/model/OpenArmsServiceResult.h
include/alibabacloud/arms/model/OpenVClusterRequest.h
include/alibabacloud/arms/model/OpenVClusterResult.h
include/alibabacloud/arms/model/QueryDatasetRequest.h
include/alibabacloud/arms/model/QueryDatasetResult.h
include/alibabacloud/arms/model/QueryMetricRequest.h
@@ -145,6 +157,8 @@ set(arms_public_header_model
include/alibabacloud/arms/model/UpdateAlertContactGroupResult.h
include/alibabacloud/arms/model/UpdateAlertRuleRequest.h
include/alibabacloud/arms/model/UpdateAlertRuleResult.h
include/alibabacloud/arms/model/UpdateDispatchRuleRequest.h
include/alibabacloud/arms/model/UpdateDispatchRuleResult.h
include/alibabacloud/arms/model/UpdateWebhookRequest.h
include/alibabacloud/arms/model/UpdateWebhookResult.h )
@@ -160,12 +174,16 @@ set(arms_src
src/model/CheckDataConsistencyResult.cc
src/model/CheckServiceLinkedRoleForDeletingRequest.cc
src/model/CheckServiceLinkedRoleForDeletingResult.cc
src/model/CheckServiceStatusRequest.cc
src/model/CheckServiceStatusResult.cc
src/model/ConfigAppRequest.cc
src/model/ConfigAppResult.cc
src/model/CreateAlertContactRequest.cc
src/model/CreateAlertContactResult.cc
src/model/CreateAlertContactGroupRequest.cc
src/model/CreateAlertContactGroupResult.cc
src/model/CreateDispatchRuleRequest.cc
src/model/CreateDispatchRuleResult.cc
src/model/CreateRetcodeAppRequest.cc
src/model/CreateRetcodeAppResult.cc
src/model/CreateWehookRequest.cc
@@ -176,6 +194,8 @@ set(arms_src
src/model/DeleteAlertContactGroupResult.cc
src/model/DeleteAlertRulesRequest.cc
src/model/DeleteAlertRulesResult.cc
src/model/DeleteDispatchRuleRequest.cc
src/model/DeleteDispatchRuleResult.cc
src/model/DeleteRetcodeAppRequest.cc
src/model/DeleteRetcodeAppResult.cc
src/model/DeleteScenarioRequest.cc
@@ -220,16 +240,22 @@ set(arms_src
src/model/ListClusterFromGrafanaResult.cc
src/model/ListDashboardsRequest.cc
src/model/ListDashboardsResult.cc
src/model/ListDispatchRuleRequest.cc
src/model/ListDispatchRuleResult.cc
src/model/ListPromClustersRequest.cc
src/model/ListPromClustersResult.cc
src/model/ListRetcodeAppsRequest.cc
src/model/ListRetcodeAppsResult.cc
src/model/ListScenarioRequest.cc
src/model/ListScenarioResult.cc
src/model/ListServerlessTopNAppsRequest.cc
src/model/ListServerlessTopNAppsResult.cc
src/model/ListTraceAppsRequest.cc
src/model/ListTraceAppsResult.cc
src/model/OpenArmsServiceRequest.cc
src/model/OpenArmsServiceResult.cc
src/model/OpenVClusterRequest.cc
src/model/OpenVClusterResult.cc
src/model/QueryDatasetRequest.cc
src/model/QueryDatasetResult.cc
src/model/QueryMetricRequest.cc
@@ -274,6 +300,8 @@ set(arms_src
src/model/UpdateAlertContactGroupResult.cc
src/model/UpdateAlertRuleRequest.cc
src/model/UpdateAlertRuleResult.cc
src/model/UpdateDispatchRuleRequest.cc
src/model/UpdateDispatchRuleResult.cc
src/model/UpdateWebhookRequest.cc
src/model/UpdateWebhookResult.cc )

56
arms/include/alibabacloud/arms/ARMSClient.h
View File

@@ -32,12 +32,16 @@
#include "model/CheckDataConsistencyResult.h"
#include "model/CheckServiceLinkedRoleForDeletingRequest.h"
#include "model/CheckServiceLinkedRoleForDeletingResult.h"
#include "model/CheckServiceStatusRequest.h"
#include "model/CheckServiceStatusResult.h"
#include "model/ConfigAppRequest.h"
#include "model/ConfigAppResult.h"
#include "model/CreateAlertContactRequest.h"
#include "model/CreateAlertContactResult.h"
#include "model/CreateAlertContactGroupRequest.h"
#include "model/CreateAlertContactGroupResult.h"
#include "model/CreateDispatchRuleRequest.h"
#include "model/CreateDispatchRuleResult.h"
#include "model/CreateRetcodeAppRequest.h"
#include "model/CreateRetcodeAppResult.h"
#include "model/CreateWehookRequest.h"
@@ -48,6 +52,8 @@
#include "model/DeleteAlertContactGroupResult.h"
#include "model/DeleteAlertRulesRequest.h"
#include "model/DeleteAlertRulesResult.h"
#include "model/DeleteDispatchRuleRequest.h"
#include "model/DeleteDispatchRuleResult.h"
#include "model/DeleteRetcodeAppRequest.h"
#include "model/DeleteRetcodeAppResult.h"
#include "model/DeleteScenarioRequest.h"
@@ -92,16 +98,22 @@
#include "model/ListClusterFromGrafanaResult.h"
#include "model/ListDashboardsRequest.h"
#include "model/ListDashboardsResult.h"
#include "model/ListDispatchRuleRequest.h"
#include "model/ListDispatchRuleResult.h"
#include "model/ListPromClustersRequest.h"
#include "model/ListPromClustersResult.h"
#include "model/ListRetcodeAppsRequest.h"
#include "model/ListRetcodeAppsResult.h"
#include "model/ListScenarioRequest.h"
#include "model/ListScenarioResult.h"
#include "model/ListServerlessTopNAppsRequest.h"
#include "model/ListServerlessTopNAppsResult.h"
#include "model/ListTraceAppsRequest.h"
#include "model/ListTraceAppsResult.h"
#include "model/OpenArmsServiceRequest.h"
#include "model/OpenArmsServiceResult.h"
#include "model/OpenVClusterRequest.h"
#include "model/OpenVClusterResult.h"
#include "model/QueryDatasetRequest.h"
#include "model/QueryDatasetResult.h"
#include "model/QueryMetricRequest.h"
@@ -146,6 +158,8 @@
#include "model/UpdateAlertContactGroupResult.h"
#include "model/UpdateAlertRuleRequest.h"
#include "model/UpdateAlertRuleResult.h"
#include "model/UpdateDispatchRuleRequest.h"
#include "model/UpdateDispatchRuleResult.h"
#include "model/UpdateWebhookRequest.h"
#include "model/UpdateWebhookResult.h"
@@ -172,6 +186,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CheckServiceLinkedRoleForDeletingResult> CheckServiceLinkedRoleForDeletingOutcome;
typedef std::future<CheckServiceLinkedRoleForDeletingOutcome> CheckServiceLinkedRoleForDeletingOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::CheckServiceLinkedRoleForDeletingRequest&, const CheckServiceLinkedRoleForDeletingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckServiceLinkedRoleForDeletingAsyncHandler;
typedef Outcome<Error, Model::CheckServiceStatusResult> CheckServiceStatusOutcome;
typedef std::future<CheckServiceStatusOutcome> CheckServiceStatusOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::CheckServiceStatusRequest&, const CheckServiceStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckServiceStatusAsyncHandler;
typedef Outcome<Error, Model::ConfigAppResult> ConfigAppOutcome;
typedef std::future<ConfigAppOutcome> ConfigAppOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ConfigAppRequest&, const ConfigAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigAppAsyncHandler;
@@ -181,6 +198,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateAlertContactGroupResult> CreateAlertContactGroupOutcome;
typedef std::future<CreateAlertContactGroupOutcome> CreateAlertContactGroupOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::CreateAlertContactGroupRequest&, const CreateAlertContactGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAlertContactGroupAsyncHandler;
typedef Outcome<Error, Model::CreateDispatchRuleResult> CreateDispatchRuleOutcome;
typedef std::future<CreateDispatchRuleOutcome> CreateDispatchRuleOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::CreateDispatchRuleRequest&, const CreateDispatchRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDispatchRuleAsyncHandler;
typedef Outcome<Error, Model::CreateRetcodeAppResult> CreateRetcodeAppOutcome;
typedef std::future<CreateRetcodeAppOutcome> CreateRetcodeAppOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::CreateRetcodeAppRequest&, const CreateRetcodeAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRetcodeAppAsyncHandler;
@@ -196,6 +216,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteAlertRulesResult> DeleteAlertRulesOutcome;
typedef std::future<DeleteAlertRulesOutcome> DeleteAlertRulesOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::DeleteAlertRulesRequest&, const DeleteAlertRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAlertRulesAsyncHandler;
typedef Outcome<Error, Model::DeleteDispatchRuleResult> DeleteDispatchRuleOutcome;
typedef std::future<DeleteDispatchRuleOutcome> DeleteDispatchRuleOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::DeleteDispatchRuleRequest&, const DeleteDispatchRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDispatchRuleAsyncHandler;
typedef Outcome<Error, Model::DeleteRetcodeAppResult> DeleteRetcodeAppOutcome;
typedef std::future<DeleteRetcodeAppOutcome> DeleteRetcodeAppOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::DeleteRetcodeAppRequest&, const DeleteRetcodeAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRetcodeAppAsyncHandler;
@@ -262,6 +285,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListDashboardsResult> ListDashboardsOutcome;
typedef std::future<ListDashboardsOutcome> ListDashboardsOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ListDashboardsRequest&, const ListDashboardsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDashboardsAsyncHandler;
typedef Outcome<Error, Model::ListDispatchRuleResult> ListDispatchRuleOutcome;
typedef std::future<ListDispatchRuleOutcome> ListDispatchRuleOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ListDispatchRuleRequest&, const ListDispatchRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDispatchRuleAsyncHandler;
typedef Outcome<Error, Model::ListPromClustersResult> ListPromClustersOutcome;
typedef std::future<ListPromClustersOutcome> ListPromClustersOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ListPromClustersRequest&, const ListPromClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPromClustersAsyncHandler;
@@ -271,12 +297,18 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListScenarioResult> ListScenarioOutcome;
typedef std::future<ListScenarioOutcome> ListScenarioOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ListScenarioRequest&, const ListScenarioOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListScenarioAsyncHandler;
typedef Outcome<Error, Model::ListServerlessTopNAppsResult> ListServerlessTopNAppsOutcome;
typedef std::future<ListServerlessTopNAppsOutcome> ListServerlessTopNAppsOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ListServerlessTopNAppsRequest&, const ListServerlessTopNAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServerlessTopNAppsAsyncHandler;
typedef Outcome<Error, Model::ListTraceAppsResult> ListTraceAppsOutcome;
typedef std::future<ListTraceAppsOutcome> ListTraceAppsOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ListTraceAppsRequest&, const ListTraceAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTraceAppsAsyncHandler;
typedef Outcome<Error, Model::OpenArmsServiceResult> OpenArmsServiceOutcome;
typedef std::future<OpenArmsServiceOutcome> OpenArmsServiceOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::OpenArmsServiceRequest&, const OpenArmsServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenArmsServiceAsyncHandler;
typedef Outcome<Error, Model::OpenVClusterResult> OpenVClusterOutcome;
typedef std::future<OpenVClusterOutcome> OpenVClusterOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::OpenVClusterRequest&, const OpenVClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenVClusterAsyncHandler;
typedef Outcome<Error, Model::QueryDatasetResult> QueryDatasetOutcome;
typedef std::future<QueryDatasetOutcome> QueryDatasetOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::QueryDatasetRequest&, const QueryDatasetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetAsyncHandler;
@@ -343,6 +375,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateAlertRuleResult> UpdateAlertRuleOutcome;
typedef std::future<UpdateAlertRuleOutcome> UpdateAlertRuleOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::UpdateAlertRuleRequest&, const UpdateAlertRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAlertRuleAsyncHandler;
typedef Outcome<Error, Model::UpdateDispatchRuleResult> UpdateDispatchRuleOutcome;
typedef std::future<UpdateDispatchRuleOutcome> UpdateDispatchRuleOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::UpdateDispatchRuleRequest&, const UpdateDispatchRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDispatchRuleAsyncHandler;
typedef Outcome<Error, Model::UpdateWebhookResult> UpdateWebhookOutcome;
typedef std::future<UpdateWebhookOutcome> UpdateWebhookOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::UpdateWebhookRequest&, const UpdateWebhookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateWebhookAsyncHandler;
@@ -366,6 +401,9 @@ namespace AlibabaCloud
CheckServiceLinkedRoleForDeletingOutcome checkServiceLinkedRoleForDeleting(const Model::CheckServiceLinkedRoleForDeletingRequest &request)const;
void checkServiceLinkedRoleForDeletingAsync(const Model::CheckServiceLinkedRoleForDeletingRequest& request, const CheckServiceLinkedRoleForDeletingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckServiceLinkedRoleForDeletingOutcomeCallable checkServiceLinkedRoleForDeletingCallable(const Model::CheckServiceLinkedRoleForDeletingRequest& request) const;
CheckServiceStatusOutcome checkServiceStatus(const Model::CheckServiceStatusRequest &request)const;
void checkServiceStatusAsync(const Model::CheckServiceStatusRequest& request, const CheckServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckServiceStatusOutcomeCallable checkServiceStatusCallable(const Model::CheckServiceStatusRequest& request) const;
ConfigAppOutcome configApp(const Model::ConfigAppRequest &request)const;
void configAppAsync(const Model::ConfigAppRequest& request, const ConfigAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ConfigAppOutcomeCallable configAppCallable(const Model::ConfigAppRequest& request) const;
@@ -375,6 +413,9 @@ namespace AlibabaCloud
CreateAlertContactGroupOutcome createAlertContactGroup(const Model::CreateAlertContactGroupRequest &request)const;
void createAlertContactGroupAsync(const Model::CreateAlertContactGroupRequest& request, const CreateAlertContactGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAlertContactGroupOutcomeCallable createAlertContactGroupCallable(const Model::CreateAlertContactGroupRequest& request) const;
CreateDispatchRuleOutcome createDispatchRule(const Model::CreateDispatchRuleRequest &request)const;
void createDispatchRuleAsync(const Model::CreateDispatchRuleRequest& request, const CreateDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDispatchRuleOutcomeCallable createDispatchRuleCallable(const Model::CreateDispatchRuleRequest& request) const;
CreateRetcodeAppOutcome createRetcodeApp(const Model::CreateRetcodeAppRequest &request)const;
void createRetcodeAppAsync(const Model::CreateRetcodeAppRequest& request, const CreateRetcodeAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRetcodeAppOutcomeCallable createRetcodeAppCallable(const Model::CreateRetcodeAppRequest& request) const;
@@ -390,6 +431,9 @@ namespace AlibabaCloud
DeleteAlertRulesOutcome deleteAlertRules(const Model::DeleteAlertRulesRequest &request)const;
void deleteAlertRulesAsync(const Model::DeleteAlertRulesRequest& request, const DeleteAlertRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAlertRulesOutcomeCallable deleteAlertRulesCallable(const Model::DeleteAlertRulesRequest& request) const;
DeleteDispatchRuleOutcome deleteDispatchRule(const Model::DeleteDispatchRuleRequest &request)const;
void deleteDispatchRuleAsync(const Model::DeleteDispatchRuleRequest& request, const DeleteDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDispatchRuleOutcomeCallable deleteDispatchRuleCallable(const Model::DeleteDispatchRuleRequest& request) const;
DeleteRetcodeAppOutcome deleteRetcodeApp(const Model::DeleteRetcodeAppRequest &request)const;
void deleteRetcodeAppAsync(const Model::DeleteRetcodeAppRequest& request, const DeleteRetcodeAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteRetcodeAppOutcomeCallable deleteRetcodeAppCallable(const Model::DeleteRetcodeAppRequest& request) const;
@@ -456,6 +500,9 @@ namespace AlibabaCloud
ListDashboardsOutcome listDashboards(const Model::ListDashboardsRequest &request)const;
void listDashboardsAsync(const Model::ListDashboardsRequest& request, const ListDashboardsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListDashboardsOutcomeCallable listDashboardsCallable(const Model::ListDashboardsRequest& request) const;
ListDispatchRuleOutcome listDispatchRule(const Model::ListDispatchRuleRequest &request)const;
void listDispatchRuleAsync(const Model::ListDispatchRuleRequest& request, const ListDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListDispatchRuleOutcomeCallable listDispatchRuleCallable(const Model::ListDispatchRuleRequest& request) const;
ListPromClustersOutcome listPromClusters(const Model::ListPromClustersRequest &request)const;
void listPromClustersAsync(const Model::ListPromClustersRequest& request, const ListPromClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListPromClustersOutcomeCallable listPromClustersCallable(const Model::ListPromClustersRequest& request) const;
@@ -465,12 +512,18 @@ namespace AlibabaCloud
ListScenarioOutcome listScenario(const Model::ListScenarioRequest &request)const;
void listScenarioAsync(const Model::ListScenarioRequest& request, const ListScenarioAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListScenarioOutcomeCallable listScenarioCallable(const Model::ListScenarioRequest& request) const;
ListServerlessTopNAppsOutcome listServerlessTopNApps(const Model::ListServerlessTopNAppsRequest &request)const;
void listServerlessTopNAppsAsync(const Model::ListServerlessTopNAppsRequest& request, const ListServerlessTopNAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListServerlessTopNAppsOutcomeCallable listServerlessTopNAppsCallable(const Model::ListServerlessTopNAppsRequest& request) const;
ListTraceAppsOutcome listTraceApps(const Model::ListTraceAppsRequest &request)const;
void listTraceAppsAsync(const Model::ListTraceAppsRequest& request, const ListTraceAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTraceAppsOutcomeCallable listTraceAppsCallable(const Model::ListTraceAppsRequest& request) const;
OpenArmsServiceOutcome openArmsService(const Model::OpenArmsServiceRequest &request)const;
void openArmsServiceAsync(const Model::OpenArmsServiceRequest& request, const OpenArmsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
OpenArmsServiceOutcomeCallable openArmsServiceCallable(const Model::OpenArmsServiceRequest& request) const;
OpenVClusterOutcome openVCluster(const Model::OpenVClusterRequest &request)const;
void openVClusterAsync(const Model::OpenVClusterRequest& request, const OpenVClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
OpenVClusterOutcomeCallable openVClusterCallable(const Model::OpenVClusterRequest& request) const;
QueryDatasetOutcome queryDataset(const Model::QueryDatasetRequest &request)const;
void queryDatasetAsync(const Model::QueryDatasetRequest& request, const QueryDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryDatasetOutcomeCallable queryDatasetCallable(const Model::QueryDatasetRequest& request) const;
@@ -537,6 +590,9 @@ namespace AlibabaCloud
UpdateAlertRuleOutcome updateAlertRule(const Model::UpdateAlertRuleRequest &request)const;
void updateAlertRuleAsync(const Model::UpdateAlertRuleRequest& request, const UpdateAlertRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateAlertRuleOutcomeCallable updateAlertRuleCallable(const Model::UpdateAlertRuleRequest& request) const;
UpdateDispatchRuleOutcome updateDispatchRule(const Model::UpdateDispatchRuleRequest &request)const;
void updateDispatchRuleAsync(const Model::UpdateDispatchRuleRequest& request, const UpdateDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateDispatchRuleOutcomeCallable updateDispatchRuleCallable(const Model::UpdateDispatchRuleRequest& request) const;
UpdateWebhookOutcome updateWebhook(const Model::UpdateWebhookRequest &request)const;
void updateWebhookAsync(const Model::UpdateWebhookRequest& request, const UpdateWebhookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateWebhookOutcomeCallable updateWebhookCallable(const Model::UpdateWebhookRequest& request) const;

51
arms/include/alibabacloud/arms/model/CheckServiceStatusRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT CheckServiceStatusRequest : public RpcServiceRequest
{
public:
CheckServiceStatusRequest();
~CheckServiceStatusRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getSvcCode()const;
void setSvcCode(const std::string& svcCode);
private:
std::string regionId_;
std::string svcCode_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSREQUEST_H_

51
arms/include/alibabacloud/arms/model/CheckServiceStatusResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT CheckServiceStatusResult : public ServiceResult
{
public:
CheckServiceStatusResult();
explicit CheckServiceStatusResult(const std::string &payload);
~CheckServiceStatusResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSRESULT_H_

54
arms/include/alibabacloud/arms/model/CreateDispatchRuleRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULEREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT CreateDispatchRuleRequest : public RpcServiceRequest
{
public:
CreateDispatchRuleRequest();
~CreateDispatchRuleRequest();
std::string getDispatchRule()const;
void setDispatchRule(const std::string& dispatchRule);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getProxyUserId()const;
void setProxyUserId(const std::string& proxyUserId);
private:
std::string dispatchRule_;
std::string regionId_;
std::string proxyUserId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULEREQUEST_H_

51
arms/include/alibabacloud/arms/model/CreateDispatchRuleResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULERESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT CreateDispatchRuleResult : public ServiceResult
{
public:
CreateDispatchRuleResult();
explicit CreateDispatchRuleResult(const std::string &payload);
~CreateDispatchRuleResult();
long getDispatchRuleId()const;
protected:
void parse(const std::string &payload);
private:
long dispatchRuleId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULERESULT_H_

54
arms/include/alibabacloud/arms/model/DeleteDispatchRuleRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULEREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT DeleteDispatchRuleRequest : public RpcServiceRequest
{
public:
DeleteDispatchRuleRequest();
~DeleteDispatchRuleRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getId()const;
void setId(const std::string& id);
std::string getProxyUserId()const;
void setProxyUserId(const std::string& proxyUserId);
private:
std::string regionId_;
std::string id_;
std::string proxyUserId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULEREQUEST_H_

51
arms/include/alibabacloud/arms/model/DeleteDispatchRuleResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULERESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT DeleteDispatchRuleResult : public ServiceResult
{
public:
DeleteDispatchRuleResult();
explicit DeleteDispatchRuleResult(const std::string &payload);
~DeleteDispatchRuleResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULERESULT_H_

3
arms/include/alibabacloud/arms/model/DeleteScenarioRequest.h
View File

@@ -35,10 +35,13 @@ namespace AlibabaCloud
DeleteScenarioRequest();
~DeleteScenarioRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
long getScenarioId()const;
void setScenarioId(long scenarioId);
private:
std::string regionId_;
long scenarioId_;
};

12
arms/include/alibabacloud/arms/model/GetMultipleTraceResult.h
View File

@@ -51,18 +51,20 @@ namespace AlibabaCloud
std::vector<LogEvent::TagEntry2> tagEntryList1;
long timestamp;
};
bool haveStack;
std::string parentSpanId;
std::string serviceIp;
std::vector<Span::LogEvent> logEventList;
std::string operationName;
std::string serviceName;
std::string rpcId;
int rpcType;
std::string traceID;
long duration;
std::vector<Span::TagEntry> tagEntryList;
long timestamp;
bool haveStack;
std::vector<Span::LogEvent> logEventList;
std::string serviceName;
std::string rpcId;
std::string traceID;
std::string resultCode;
std::string spanId;
};
std::string traceID;
std::vector<MultiCallChainInfo::Span> spans;

12
arms/include/alibabacloud/arms/model/GetTraceResult.h
View File

@@ -49,18 +49,20 @@ namespace AlibabaCloud
std::vector<LogEvent::TagEntry2> tagEntryList1;
long timestamp;
};
bool haveStack;
std::string parentSpanId;
std::string serviceIp;
std::vector<Span::LogEvent> logEventList;
std::string operationName;
std::string serviceName;
std::string rpcId;
int rpcType;
std::string traceID;
long duration;
std::vector<Span::TagEntry> tagEntryList;
long timestamp;
bool haveStack;
std::vector<Span::LogEvent> logEventList;
std::string serviceName;
std::string rpcId;
std::string traceID;
std::string resultCode;
std::string spanId;
};

57
arms/include/alibabacloud/arms/model/ListDispatchRuleRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULEREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT ListDispatchRuleRequest : public RpcServiceRequest
{
public:
ListDispatchRuleRequest();
~ListDispatchRuleRequest();
bool getSystem()const;
void setSystem(bool system);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getName()const;
void setName(const std::string& name);
std::string getProxyUserId()const;
void setProxyUserId(const std::string& proxyUserId);
private:
bool system_;
std::string regionId_;
std::string name_;
std::string proxyUserId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULEREQUEST_H_

57
arms/include/alibabacloud/arms/model/ListDispatchRuleResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULERESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT ListDispatchRuleResult : public ServiceResult
{
public:
struct DispatchRule
{
std::string state;
long ruleId;
std::string name;
};
ListDispatchRuleResult();
explicit ListDispatchRuleResult(const std::string &payload);
~ListDispatchRuleResult();
std::vector<DispatchRule> getDispatchRules()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DispatchRule> dispatchRules_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULERESULT_H_

60
arms/include/alibabacloud/arms/model/ListServerlessTopNAppsRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT ListServerlessTopNAppsRequest : public RpcServiceRequest
{
public:
ListServerlessTopNAppsRequest();
~ListServerlessTopNAppsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getLimit()const;
void setLimit(int limit);
std::string getOrderBy()const;
void setOrderBy(const std::string& orderBy);
long getEndTime()const;
void setEndTime(long endTime);
long getStartTime()const;
void setStartTime(long startTime);
private:
std::string regionId_;
int limit_;
std::string orderBy_;
long endTime_;
long startTime_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSREQUEST_H_

60
arms/include/alibabacloud/arms/model/ListServerlessTopNAppsResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT ListServerlessTopNAppsResult : public ServiceResult
{
public:
struct DataItem
{
float rt;
std::string region;
int error;
std::string pid;
int count;
std::string name;
};
ListServerlessTopNAppsResult();
explicit ListServerlessTopNAppsResult(const std::string &payload);
~ListServerlessTopNAppsResult();
std::vector<DataItem> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DataItem> data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSRESULT_H_

54
arms/include/alibabacloud/arms/model/OpenVClusterRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT OpenVClusterRequest : public RpcServiceRequest
{
public:
OpenVClusterRequest();
~OpenVClusterRequest();
std::string getClusterType()const;
void setClusterType(const std::string& clusterType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getLength()const;
void setLength(int length);
private:
std::string clusterType_;
std::string regionId_;
int length_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERREQUEST_H_

51
arms/include/alibabacloud/arms/model/OpenVClusterResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT OpenVClusterResult : public ServiceResult
{
public:
OpenVClusterResult();
explicit OpenVClusterResult(const std::string &payload);
~OpenVClusterResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERRESULT_H_

3
arms/include/alibabacloud/arms/model/QueryMetricByPageRequest.h
View File

@@ -63,6 +63,8 @@ namespace AlibabaCloud
void setIntervalInSec(int intervalInSec);
std::string getMetric()const;
void setMetric(const std::string& metric);
std::vector<std::string> getCustomFilters()const;
void setCustomFilters(const std::vector<std::string>& customFilters);
int getPageSize()const;
void setPageSize(int pageSize);
std::vector<std::string> getDimensions()const;
@@ -82,6 +84,7 @@ namespace AlibabaCloud
std::vector<std::string> measures_;
int intervalInSec_;
std::string metric_;
std::vector<std::string> customFilters_;
int pageSize_;
std::vector<std::string> dimensions_;
std::string order_;

54
arms/include/alibabacloud/arms/model/UpdateDispatchRuleRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULEREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT UpdateDispatchRuleRequest : public RpcServiceRequest
{
public:
UpdateDispatchRuleRequest();
~UpdateDispatchRuleRequest();
std::string getDispatchRule()const;
void setDispatchRule(const std::string& dispatchRule);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getProxyUserId()const;
void setProxyUserId(const std::string& proxyUserId);
private:
std::string dispatchRule_;
std::string regionId_;
std::string proxyUserId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULEREQUEST_H_

51
arms/include/alibabacloud/arms/model/UpdateDispatchRuleResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULERESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT UpdateDispatchRuleResult : public ServiceResult
{
public:
UpdateDispatchRuleResult();
explicit UpdateDispatchRuleResult(const std::string &payload);
~UpdateDispatchRuleResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULERESULT_H_

252
arms/src/ARMSClient.cc
View File

@@ -231,6 +231,42 @@ ARMSClient::CheckServiceLinkedRoleForDeletingOutcomeCallable ARMSClient::checkSe
return task->get_future();
}
ARMSClient::CheckServiceStatusOutcome ARMSClient::checkServiceStatus(const CheckServiceStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckServiceStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckServiceStatusOutcome(CheckServiceStatusResult(outcome.result()));
else
return CheckServiceStatusOutcome(outcome.error());
}
void ARMSClient::checkServiceStatusAsync(const CheckServiceStatusRequest& request, const CheckServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkServiceStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::CheckServiceStatusOutcomeCallable ARMSClient::checkServiceStatusCallable(const CheckServiceStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckServiceStatusOutcome()>>(
[this, request]()
{
return this->checkServiceStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::ConfigAppOutcome ARMSClient::configApp(const ConfigAppRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +375,42 @@ ARMSClient::CreateAlertContactGroupOutcomeCallable ARMSClient::createAlertContac
return task->get_future();
}
ARMSClient::CreateDispatchRuleOutcome ARMSClient::createDispatchRule(const CreateDispatchRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDispatchRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDispatchRuleOutcome(CreateDispatchRuleResult(outcome.result()));
else
return CreateDispatchRuleOutcome(outcome.error());
}
void ARMSClient::createDispatchRuleAsync(const CreateDispatchRuleRequest& request, const CreateDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDispatchRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::CreateDispatchRuleOutcomeCallable ARMSClient::createDispatchRuleCallable(const CreateDispatchRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDispatchRuleOutcome()>>(
[this, request]()
{
return this->createDispatchRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::CreateRetcodeAppOutcome ARMSClient::createRetcodeApp(const CreateRetcodeAppRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,6 +591,42 @@ ARMSClient::DeleteAlertRulesOutcomeCallable ARMSClient::deleteAlertRulesCallable
return task->get_future();
}
ARMSClient::DeleteDispatchRuleOutcome ARMSClient::deleteDispatchRule(const DeleteDispatchRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDispatchRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDispatchRuleOutcome(DeleteDispatchRuleResult(outcome.result()));
else
return DeleteDispatchRuleOutcome(outcome.error());
}
void ARMSClient::deleteDispatchRuleAsync(const DeleteDispatchRuleRequest& request, const DeleteDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDispatchRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::DeleteDispatchRuleOutcomeCallable ARMSClient::deleteDispatchRuleCallable(const DeleteDispatchRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDispatchRuleOutcome()>>(
[this, request]()
{
return this->deleteDispatchRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::DeleteRetcodeAppOutcome ARMSClient::deleteRetcodeApp(const DeleteRetcodeAppRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1311,6 +1419,42 @@ ARMSClient::ListDashboardsOutcomeCallable ARMSClient::listDashboardsCallable(con
return task->get_future();
}
ARMSClient::ListDispatchRuleOutcome ARMSClient::listDispatchRule(const ListDispatchRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListDispatchRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListDispatchRuleOutcome(ListDispatchRuleResult(outcome.result()));
else
return ListDispatchRuleOutcome(outcome.error());
}
void ARMSClient::listDispatchRuleAsync(const ListDispatchRuleRequest& request, const ListDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listDispatchRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::ListDispatchRuleOutcomeCallable ARMSClient::listDispatchRuleCallable(const ListDispatchRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListDispatchRuleOutcome()>>(
[this, request]()
{
return this->listDispatchRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::ListPromClustersOutcome ARMSClient::listPromClusters(const ListPromClustersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1419,6 +1563,42 @@ ARMSClient::ListScenarioOutcomeCallable ARMSClient::listScenarioCallable(const L
return task->get_future();
}
ARMSClient::ListServerlessTopNAppsOutcome ARMSClient::listServerlessTopNApps(const ListServerlessTopNAppsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListServerlessTopNAppsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListServerlessTopNAppsOutcome(ListServerlessTopNAppsResult(outcome.result()));
else
return ListServerlessTopNAppsOutcome(outcome.error());
}
void ARMSClient::listServerlessTopNAppsAsync(const ListServerlessTopNAppsRequest& request, const ListServerlessTopNAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listServerlessTopNApps(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::ListServerlessTopNAppsOutcomeCallable ARMSClient::listServerlessTopNAppsCallable(const ListServerlessTopNAppsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListServerlessTopNAppsOutcome()>>(
[this, request]()
{
return this->listServerlessTopNApps(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::ListTraceAppsOutcome ARMSClient::listTraceApps(const ListTraceAppsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,6 +1671,42 @@ ARMSClient::OpenArmsServiceOutcomeCallable ARMSClient::openArmsServiceCallable(c
return task->get_future();
}
ARMSClient::OpenVClusterOutcome ARMSClient::openVCluster(const OpenVClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return OpenVClusterOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return OpenVClusterOutcome(OpenVClusterResult(outcome.result()));
else
return OpenVClusterOutcome(outcome.error());
}
void ARMSClient::openVClusterAsync(const OpenVClusterRequest& request, const OpenVClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, openVCluster(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::OpenVClusterOutcomeCallable ARMSClient::openVClusterCallable(const OpenVClusterRequest &request) const
{
auto task = std::make_shared<std::packaged_task<OpenVClusterOutcome()>>(
[this, request]()
{
return this->openVCluster(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::QueryDatasetOutcome ARMSClient::queryDataset(const QueryDatasetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2499,42 @@ ARMSClient::UpdateAlertRuleOutcomeCallable ARMSClient::updateAlertRuleCallable(c
return task->get_future();
}
ARMSClient::UpdateDispatchRuleOutcome ARMSClient::updateDispatchRule(const UpdateDispatchRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateDispatchRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateDispatchRuleOutcome(UpdateDispatchRuleResult(outcome.result()));
else
return UpdateDispatchRuleOutcome(outcome.error());
}
void ARMSClient::updateDispatchRuleAsync(const UpdateDispatchRuleRequest& request, const UpdateDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateDispatchRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::UpdateDispatchRuleOutcomeCallable ARMSClient::updateDispatchRuleCallable(const UpdateDispatchRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateDispatchRuleOutcome()>>(
[this, request]()
{
return this->updateDispatchRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::UpdateWebhookOutcome ARMSClient::updateWebhook(const UpdateWebhookRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

51
arms/src/model/CheckServiceStatusRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/CheckServiceStatusRequest.h>
using AlibabaCloud::ARMS::Model::CheckServiceStatusRequest;
CheckServiceStatusRequest::CheckServiceStatusRequest() :
RpcServiceRequest("arms", "2019-08-08", "CheckServiceStatus")
{
setMethod(HttpRequest::Method::Post);
}
CheckServiceStatusRequest::~CheckServiceStatusRequest()
{}
std::string CheckServiceStatusRequest::getRegionId()const
{
return regionId_;
}
void CheckServiceStatusRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CheckServiceStatusRequest::getSvcCode()const
{
return svcCode_;
}
void CheckServiceStatusRequest::setSvcCode(const std::string& svcCode)
{
svcCode_ = svcCode;
setParameter("SvcCode", svcCode);
}

51
arms/src/model/CheckServiceStatusResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/CheckServiceStatusResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
CheckServiceStatusResult::CheckServiceStatusResult() :
ServiceResult()
{}
CheckServiceStatusResult::CheckServiceStatusResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CheckServiceStatusResult::~CheckServiceStatusResult()
{}
void CheckServiceStatusResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string CheckServiceStatusResult::getData()const
{
return data_;
}

62
arms/src/model/CreateDispatchRuleRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/CreateDispatchRuleRequest.h>
using AlibabaCloud::ARMS::Model::CreateDispatchRuleRequest;
CreateDispatchRuleRequest::CreateDispatchRuleRequest() :
RpcServiceRequest("arms", "2019-08-08", "CreateDispatchRule")
{
setMethod(HttpRequest::Method::Post);
}
CreateDispatchRuleRequest::~CreateDispatchRuleRequest()
{}
std::string CreateDispatchRuleRequest::getDispatchRule()const
{
return dispatchRule_;
}
void CreateDispatchRuleRequest::setDispatchRule(const std::string& dispatchRule)
{
dispatchRule_ = dispatchRule;
setParameter("DispatchRule", dispatchRule);
}
std::string CreateDispatchRuleRequest::getRegionId()const
{
return regionId_;
}
void CreateDispatchRuleRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDispatchRuleRequest::getProxyUserId()const
{
return proxyUserId_;
}
void CreateDispatchRuleRequest::setProxyUserId(const std::string& proxyUserId)
{
proxyUserId_ = proxyUserId;
setParameter("ProxyUserId", proxyUserId);
}

51
arms/src/model/CreateDispatchRuleResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/CreateDispatchRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
CreateDispatchRuleResult::CreateDispatchRuleResult() :
ServiceResult()
{}
CreateDispatchRuleResult::CreateDispatchRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDispatchRuleResult::~CreateDispatchRuleResult()
{}
void CreateDispatchRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["DispatchRuleId"].isNull())
dispatchRuleId_ = std::stol(value["DispatchRuleId"].asString());
}
long CreateDispatchRuleResult::getDispatchRuleId()const
{
return dispatchRuleId_;
}

62
arms/src/model/DeleteDispatchRuleRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/DeleteDispatchRuleRequest.h>
using AlibabaCloud::ARMS::Model::DeleteDispatchRuleRequest;
DeleteDispatchRuleRequest::DeleteDispatchRuleRequest() :
RpcServiceRequest("arms", "2019-08-08", "DeleteDispatchRule")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDispatchRuleRequest::~DeleteDispatchRuleRequest()
{}
std::string DeleteDispatchRuleRequest::getRegionId()const
{
return regionId_;
}
void DeleteDispatchRuleRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteDispatchRuleRequest::getId()const
{
return id_;
}
void DeleteDispatchRuleRequest::setId(const std::string& id)
{
id_ = id;
setParameter("Id", id);
}
std::string DeleteDispatchRuleRequest::getProxyUserId()const
{
return proxyUserId_;
}
void DeleteDispatchRuleRequest::setProxyUserId(const std::string& proxyUserId)
{
proxyUserId_ = proxyUserId;
setParameter("ProxyUserId", proxyUserId);
}

51
arms/src/model/DeleteDispatchRuleResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/DeleteDispatchRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
DeleteDispatchRuleResult::DeleteDispatchRuleResult() :
ServiceResult()
{}
DeleteDispatchRuleResult::DeleteDispatchRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteDispatchRuleResult::~DeleteDispatchRuleResult()
{}
void DeleteDispatchRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool DeleteDispatchRuleResult::getSuccess()const
{
return success_;
}

11
arms/src/model/DeleteScenarioRequest.cc
View File

@@ -27,6 +27,17 @@ DeleteScenarioRequest::DeleteScenarioRequest() :
DeleteScenarioRequest::~DeleteScenarioRequest()
{}
std::string DeleteScenarioRequest::getRegionId()const
{
return regionId_;
}
void DeleteScenarioRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
long DeleteScenarioRequest::getScenarioId()const
{
return scenarioId_;

4
arms/src/model/GetMultipleTraceResult.cc
View File

@@ -69,6 +69,10 @@ void GetMultipleTraceResult::parse(const std::string &payload)
spansObject.haveStack = valueMultiCallChainInfosMultiCallChainInfoSpansSpan["HaveStack"].asString() == "true";
if(!valueMultiCallChainInfosMultiCallChainInfoSpansSpan["RpcType"].isNull())
spansObject.rpcType = std::stoi(valueMultiCallChainInfosMultiCallChainInfoSpansSpan["RpcType"].asString());
if(!valueMultiCallChainInfosMultiCallChainInfoSpansSpan["SpanId"].isNull())
spansObject.spanId = valueMultiCallChainInfosMultiCallChainInfoSpansSpan["SpanId"].asString();
if(!valueMultiCallChainInfosMultiCallChainInfoSpansSpan["ParentSpanId"].isNull())
spansObject.parentSpanId = valueMultiCallChainInfosMultiCallChainInfoSpansSpan["ParentSpanId"].asString();
auto allTagEntryListNode = valueMultiCallChainInfosMultiCallChainInfoSpansSpan["TagEntryList"]["TagEntry"];
for (auto valueMultiCallChainInfosMultiCallChainInfoSpansSpanTagEntryListTagEntry : allTagEntryListNode)
{

4
arms/src/model/GetTraceResult.cc
View File

@@ -63,6 +63,10 @@ void GetTraceResult::parse(const std::string &payload)
spansObject.haveStack = valueSpansSpan["HaveStack"].asString() == "true";
if(!valueSpansSpan["RpcType"].isNull())
spansObject.rpcType = std::stoi(valueSpansSpan["RpcType"].asString());
if(!valueSpansSpan["SpanId"].isNull())
spansObject.spanId = valueSpansSpan["SpanId"].asString();
if(!valueSpansSpan["ParentSpanId"].isNull())
spansObject.parentSpanId = valueSpansSpan["ParentSpanId"].asString();
auto allTagEntryListNode = valueSpansSpan["TagEntryList"]["TagEntry"];
for (auto valueSpansSpanTagEntryListTagEntry : allTagEntryListNode)
{

73
arms/src/model/ListDispatchRuleRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/ListDispatchRuleRequest.h>
using AlibabaCloud::ARMS::Model::ListDispatchRuleRequest;
ListDispatchRuleRequest::ListDispatchRuleRequest() :
RpcServiceRequest("arms", "2019-08-08", "ListDispatchRule")
{
setMethod(HttpRequest::Method::Post);
}
ListDispatchRuleRequest::~ListDispatchRuleRequest()
{}
bool ListDispatchRuleRequest::getSystem()const
{
return system_;
}
void ListDispatchRuleRequest::setSystem(bool system)
{
system_ = system;
setParameter("System", system ? "true" : "false");
}
std::string ListDispatchRuleRequest::getRegionId()const
{
return regionId_;
}
void ListDispatchRuleRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListDispatchRuleRequest::getName()const
{
return name_;
}
void ListDispatchRuleRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
std::string ListDispatchRuleRequest::getProxyUserId()const
{
return proxyUserId_;
}
void ListDispatchRuleRequest::setProxyUserId(const std::string& proxyUserId)
{
proxyUserId_ = proxyUserId;
setParameter("ProxyUserId", proxyUserId);
}

61
arms/src/model/ListDispatchRuleResult.cc Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/ListDispatchRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
ListDispatchRuleResult::ListDispatchRuleResult() :
ServiceResult()
{}
ListDispatchRuleResult::ListDispatchRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListDispatchRuleResult::~ListDispatchRuleResult()
{}
void ListDispatchRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDispatchRulesNode = value["DispatchRules"]["DispatchRule"];
for (auto valueDispatchRulesDispatchRule : allDispatchRulesNode)
{
DispatchRule dispatchRulesObject;
if(!valueDispatchRulesDispatchRule["RuleId"].isNull())
dispatchRulesObject.ruleId = std::stol(valueDispatchRulesDispatchRule["RuleId"].asString());
if(!valueDispatchRulesDispatchRule["Name"].isNull())
dispatchRulesObject.name = valueDispatchRulesDispatchRule["Name"].asString();
if(!valueDispatchRulesDispatchRule["State"].isNull())
dispatchRulesObject.state = valueDispatchRulesDispatchRule["State"].asString();
dispatchRules_.push_back(dispatchRulesObject);
}
}
std::vector<ListDispatchRuleResult::DispatchRule> ListDispatchRuleResult::getDispatchRules()const
{
return dispatchRules_;
}

84
arms/src/model/ListServerlessTopNAppsRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/ListServerlessTopNAppsRequest.h>
using AlibabaCloud::ARMS::Model::ListServerlessTopNAppsRequest;
ListServerlessTopNAppsRequest::ListServerlessTopNAppsRequest() :
RpcServiceRequest("arms", "2019-08-08", "ListServerlessTopNApps")
{
setMethod(HttpRequest::Method::Post);
}
ListServerlessTopNAppsRequest::~ListServerlessTopNAppsRequest()
{}
std::string ListServerlessTopNAppsRequest::getRegionId()const
{
return regionId_;
}
void ListServerlessTopNAppsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int ListServerlessTopNAppsRequest::getLimit()const
{
return limit_;
}
void ListServerlessTopNAppsRequest::setLimit(int limit)
{
limit_ = limit;
setParameter("Limit", std::to_string(limit));
}
std::string ListServerlessTopNAppsRequest::getOrderBy()const
{
return orderBy_;
}
void ListServerlessTopNAppsRequest::setOrderBy(const std::string& orderBy)
{
orderBy_ = orderBy;
setParameter("OrderBy", orderBy);
}
long ListServerlessTopNAppsRequest::getEndTime()const
{
return endTime_;
}
void ListServerlessTopNAppsRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setParameter("EndTime", std::to_string(endTime));
}
long ListServerlessTopNAppsRequest::getStartTime()const
{
return startTime_;
}
void ListServerlessTopNAppsRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setParameter("StartTime", std::to_string(startTime));
}

67
arms/src/model/ListServerlessTopNAppsResult.cc Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/ListServerlessTopNAppsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
ListServerlessTopNAppsResult::ListServerlessTopNAppsResult() :
ServiceResult()
{}
ListServerlessTopNAppsResult::ListServerlessTopNAppsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListServerlessTopNAppsResult::~ListServerlessTopNAppsResult()
{}
void ListServerlessTopNAppsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["DataItem"];
for (auto valueDataDataItem : allDataNode)
{
DataItem dataObject;
if(!valueDataDataItem["Pid"].isNull())
dataObject.pid = valueDataDataItem["Pid"].asString();
if(!valueDataDataItem["Name"].isNull())
dataObject.name = valueDataDataItem["Name"].asString();
if(!valueDataDataItem["Region"].isNull())
dataObject.region = valueDataDataItem["Region"].asString();
if(!valueDataDataItem["Rt"].isNull())
dataObject.rt = std::stof(valueDataDataItem["Rt"].asString());
if(!valueDataDataItem["Count"].isNull())
dataObject.count = std::stoi(valueDataDataItem["Count"].asString());
if(!valueDataDataItem["Error"].isNull())
dataObject.error = std::stoi(valueDataDataItem["Error"].asString());
data_.push_back(dataObject);
}
}
std::vector<ListServerlessTopNAppsResult::DataItem> ListServerlessTopNAppsResult::getData()const
{
return data_;
}

62
arms/src/model/OpenVClusterRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/OpenVClusterRequest.h>
using AlibabaCloud::ARMS::Model::OpenVClusterRequest;
OpenVClusterRequest::OpenVClusterRequest() :
RpcServiceRequest("arms", "2019-08-08", "OpenVCluster")
{
setMethod(HttpRequest::Method::Post);
}
OpenVClusterRequest::~OpenVClusterRequest()
{}
std::string OpenVClusterRequest::getClusterType()const
{
return clusterType_;
}
void OpenVClusterRequest::setClusterType(const std::string& clusterType)
{
clusterType_ = clusterType;
setParameter("ClusterType", clusterType);
}
std::string OpenVClusterRequest::getRegionId()const
{
return regionId_;
}
void OpenVClusterRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int OpenVClusterRequest::getLength()const
{
return length_;
}
void OpenVClusterRequest::setLength(int length)
{
length_ = length;
setParameter("Length", std::to_string(length));
}

51
arms/src/model/OpenVClusterResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/OpenVClusterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
OpenVClusterResult::OpenVClusterResult() :
ServiceResult()
{}
OpenVClusterResult::OpenVClusterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
OpenVClusterResult::~OpenVClusterResult()
{}
void OpenVClusterResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string OpenVClusterResult::getData()const
{
return data_;
}

13
arms/src/model/QueryMetricByPageRequest.cc
View File

@@ -155,6 +155,19 @@ void QueryMetricByPageRequest::setMetric(const std::string& metric)
setParameter("Metric", metric);
}
std::vector<std::string> QueryMetricByPageRequest::getCustomFilters()const
{
return customFilters_;
}
void QueryMetricByPageRequest::setCustomFilters(const std::vector<std::string>& customFilters)
{
customFilters_ = customFilters;
for(int dep1 = 0; dep1!= customFilters.size(); dep1++) {
setParameter("CustomFilters."+ std::to_string(dep1), customFilters.at(dep1));
}
}
int QueryMetricByPageRequest::getPageSize()const
{
return pageSize_;

62
arms/src/model/UpdateDispatchRuleRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/UpdateDispatchRuleRequest.h>
using AlibabaCloud::ARMS::Model::UpdateDispatchRuleRequest;
UpdateDispatchRuleRequest::UpdateDispatchRuleRequest() :
RpcServiceRequest("arms", "2019-08-08", "UpdateDispatchRule")
{
setMethod(HttpRequest::Method::Post);
}
UpdateDispatchRuleRequest::~UpdateDispatchRuleRequest()
{}
std::string UpdateDispatchRuleRequest::getDispatchRule()const
{
return dispatchRule_;
}
void UpdateDispatchRuleRequest::setDispatchRule(const std::string& dispatchRule)
{
dispatchRule_ = dispatchRule;
setParameter("DispatchRule", dispatchRule);
}
std::string UpdateDispatchRuleRequest::getRegionId()const
{
return regionId_;
}
void UpdateDispatchRuleRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string UpdateDispatchRuleRequest::getProxyUserId()const
{
return proxyUserId_;
}
void UpdateDispatchRuleRequest::setProxyUserId(const std::string& proxyUserId)
{
proxyUserId_ = proxyUserId;
setParameter("ProxyUserId", proxyUserId);
}

51
arms/src/model/UpdateDispatchRuleResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/UpdateDispatchRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
UpdateDispatchRuleResult::UpdateDispatchRuleResult() :
ServiceResult()
{}
UpdateDispatchRuleResult::UpdateDispatchRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateDispatchRuleResult::~UpdateDispatchRuleResult()
{}
void UpdateDispatchRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool UpdateDispatchRuleResult::getSuccess()const
{
return success_;
}