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

ARMS SDK Auto Released By shichun.fsc,Version：1.36.40

Browse Source 
Signed-off-by: sdk-team <sdk-team@alibabacloud.com>
This commit is contained in:
sdk-team
2019-05-31 14:38:45 +08:00
parent f3144309f2
commit cab1294e1a
42 changed files with 3016 additions and 740 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
arms/CMakeLists.txt
View File

@@ -1,90 +1,82 @@
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(arms_public_header
include/alibabacloud/arms/ARMSClient.h
include/alibabacloud/arms/ARMSExport.h )
set(arms_public_header_model
include/alibabacloud/arms/model/ARMSQueryDataSetRequest.h
include/alibabacloud/arms/model/ARMSQueryDataSetResult.h
include/alibabacloud/arms/model/MetricQueryRequest.h
include/alibabacloud/arms/model/MetricQueryResult.h )
include/alibabacloud/arms/ARMSExport.h )
set(arms_public_header_model )
set(arms_src
src/ARMSClient.cc
src/model/ARMSQueryDataSetRequest.cc
src/model/ARMSQueryDataSetResult.cc
src/model/MetricQueryRequest.cc
src/model/MetricQueryResult.cc )
add_library(arms ${LIB_TYPE}
${arms_public_header}
${arms_public_header_model}
${arms_src})
set_target_properties(arms
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}arms
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(arms
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_ARMS_LIBRARY)
endif()
target_include_directories(arms
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(arms
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(arms
jsoncpp)
target_include_directories(arms
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(arms
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(arms
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(arms
PRIVATE /usr/include/jsoncpp)
target_link_libraries(arms
jsoncpp)
endif()
install(FILES ${arms_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/arms)
install(FILES ${arms_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/arms/model)
install(TARGETS arms
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
src/ARMSClient.cc )
add_library(arms ${LIB_TYPE}
${arms_public_header}
${arms_public_header_model}
${arms_src})
set_target_properties(arms
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}arms
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(arms
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_ARMS_LIBRARY)
endif()
target_include_directories(arms
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(arms
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(arms
jsoncpp)
target_include_directories(arms
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(arms
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(arms
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(arms
PRIVATE /usr/include/jsoncpp)
target_link_libraries(arms
jsoncpp)
endif()
install(FILES ${arms_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/arms)
install(FILES ${arms_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/arms/model)
install(TARGETS arms
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

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

@@ -1,62 +1,118 @@
/*
* 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_ARMSCLIENT_H_
#define ALIBABACLOUD_ARMS_ARMSCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ARMSExport.h"
/*
* 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_ARMSCLIENT_H_
#define ALIBABACLOUD_ARMS_ARMSCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ARMSExport.h"
#include "model/GetTraceRequest.h"
#include "model/GetTraceResult.h"
#include "model/SearchTracesRequest.h"
#include "model/SearchTracesResult.h"
#include "model/SearchTraceCountRequest.h"
#include "model/SearchTraceCountResult.h"
#include "model/GetTagKeyRequest.h"
#include "model/GetTagKeyResult.h"
#include "model/ARMSQueryDataSetRequest.h"
#include "model/ARMSQueryDataSetResult.h"
#include "model/GetSpanNamesRequest.h"
#include "model/GetSpanNamesResult.h"
#include "model/GetServicesRequest.h"
#include "model/GetServicesResult.h"
#include "model/MetricQueryRequest.h"
#include "model/MetricQueryResult.h"
namespace AlibabaCloud
{
namespace ARMS
{
class ALIBABACLOUD_ARMS_EXPORT ARMSClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::ARMSQueryDataSetResult> ARMSQueryDataSetOutcome;
typedef std::future<ARMSQueryDataSetOutcome> ARMSQueryDataSetOutcomeCallable;
#include "model/GetTagValRequest.h"
#include "model/GetTagValResult.h"
namespace AlibabaCloud
{
namespace ARMS
{
class ALIBABACLOUD_ARMS_EXPORT ARMSClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::GetTraceResult> GetTraceOutcome;
typedef std::future<GetTraceOutcome> GetTraceOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetTraceRequest&, const GetTraceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTraceAsyncHandler;
typedef Outcome<Error, Model::SearchTracesResult> SearchTracesOutcome;
typedef std::future<SearchTracesOutcome> SearchTracesOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchTracesRequest&, const SearchTracesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchTracesAsyncHandler;
typedef Outcome<Error, Model::SearchTraceCountResult> SearchTraceCountOutcome;
typedef std::future<SearchTraceCountOutcome> SearchTraceCountOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchTraceCountRequest&, const SearchTraceCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchTraceCountAsyncHandler;
typedef Outcome<Error, Model::GetTagKeyResult> GetTagKeyOutcome;
typedef std::future<GetTagKeyOutcome> GetTagKeyOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetTagKeyRequest&, const GetTagKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagKeyAsyncHandler;
typedef Outcome<Error, Model::ARMSQueryDataSetResult> ARMSQueryDataSetOutcome;
typedef std::future<ARMSQueryDataSetOutcome> ARMSQueryDataSetOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ARMSQueryDataSetRequest&, const ARMSQueryDataSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ARMSQueryDataSetAsyncHandler;
typedef Outcome<Error, Model::MetricQueryResult> MetricQueryOutcome;
typedef std::future<MetricQueryOutcome> MetricQueryOutcomeCallable;
typedef Outcome<Error, Model::GetSpanNamesResult> GetSpanNamesOutcome;
typedef std::future<GetSpanNamesOutcome> GetSpanNamesOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetSpanNamesRequest&, const GetSpanNamesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSpanNamesAsyncHandler;
typedef Outcome<Error, Model::GetServicesResult> GetServicesOutcome;
typedef std::future<GetServicesOutcome> GetServicesOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetServicesRequest&, const GetServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServicesAsyncHandler;
typedef Outcome<Error, Model::MetricQueryResult> MetricQueryOutcome;
typedef std::future<MetricQueryOutcome> MetricQueryOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::MetricQueryRequest&, const MetricQueryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MetricQueryAsyncHandler;
ARMSClient(const Credentials &credentials, const ClientConfiguration &configuration);
ARMSClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ARMSClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ARMSClient();
ARMSQueryDataSetOutcome aRMSQueryDataSet(const Model::ARMSQueryDataSetRequest &request)const;
void aRMSQueryDataSetAsync(const Model::ARMSQueryDataSetRequest& request, const ARMSQueryDataSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
typedef Outcome<Error, Model::GetTagValResult> GetTagValOutcome;
typedef std::future<GetTagValOutcome> GetTagValOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetTagValRequest&, const GetTagValOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagValAsyncHandler;
ARMSClient(const Credentials &credentials, const ClientConfiguration &configuration);
ARMSClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ARMSClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ARMSClient();
GetTraceOutcome getTrace(const Model::GetTraceRequest &request)const;
void getTraceAsync(const Model::GetTraceRequest& request, const GetTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTraceOutcomeCallable getTraceCallable(const Model::GetTraceRequest& request) const;
SearchTracesOutcome searchTraces(const Model::SearchTracesRequest &request)const;
void searchTracesAsync(const Model::SearchTracesRequest& request, const SearchTracesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchTracesOutcomeCallable searchTracesCallable(const Model::SearchTracesRequest& request) const;
SearchTraceCountOutcome searchTraceCount(const Model::SearchTraceCountRequest &request)const;
void searchTraceCountAsync(const Model::SearchTraceCountRequest& request, const SearchTraceCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchTraceCountOutcomeCallable searchTraceCountCallable(const Model::SearchTraceCountRequest& request) const;
GetTagKeyOutcome getTagKey(const Model::GetTagKeyRequest &request)const;
void getTagKeyAsync(const Model::GetTagKeyRequest& request, const GetTagKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTagKeyOutcomeCallable getTagKeyCallable(const Model::GetTagKeyRequest& request) const;
ARMSQueryDataSetOutcome aRMSQueryDataSet(const Model::ARMSQueryDataSetRequest &request)const;
void aRMSQueryDataSetAsync(const Model::ARMSQueryDataSetRequest& request, const ARMSQueryDataSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ARMSQueryDataSetOutcomeCallable aRMSQueryDataSetCallable(const Model::ARMSQueryDataSetRequest& request) const;
MetricQueryOutcome metricQuery(const Model::MetricQueryRequest &request)const;
void metricQueryAsync(const Model::MetricQueryRequest& request, const MetricQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetSpanNamesOutcome getSpanNames(const Model::GetSpanNamesRequest &request)const;
void getSpanNamesAsync(const Model::GetSpanNamesRequest& request, const GetSpanNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetSpanNamesOutcomeCallable getSpanNamesCallable(const Model::GetSpanNamesRequest& request) const;
GetServicesOutcome getServices(const Model::GetServicesRequest &request)const;
void getServicesAsync(const Model::GetServicesRequest& request, const GetServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetServicesOutcomeCallable getServicesCallable(const Model::GetServicesRequest& request) const;
MetricQueryOutcome metricQuery(const Model::MetricQueryRequest &request)const;
void metricQueryAsync(const Model::MetricQueryRequest& request, const MetricQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MetricQueryOutcomeCallable metricQueryCallable(const Model::MetricQueryRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_ARMS_ARMSCLIENT_H_
GetTagValOutcome getTagVal(const Model::GetTagValRequest &request)const;
void getTagValAsync(const Model::GetTagValRequest& request, const GetTagValAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTagValOutcomeCallable getTagValCallable(const Model::GetTagValRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_ARMS_ARMSCLIENT_H_

62
arms/include/alibabacloud/arms/ARMSExport.h
View File

@@ -1,32 +1,32 @@
/*
* 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_ARMSEXPORT_H_
#define ALIBABACLOUD_ARMS_ARMSEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_ARMS_LIBRARY)
# define ALIBABACLOUD_ARMS_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_ARMS_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_ARMS_EXPORT
#endif
/*
* 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_ARMSEXPORT_H_
#define ALIBABACLOUD_ARMS_ARMSEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_ARMS_LIBRARY)
# define ALIBABACLOUD_ARMS_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_ARMS_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_ARMS_EXPORT
#endif
#endif // !ALIBABACLOUD_ARMS_ARMSEXPORT_H_

88
arms/include/alibabacloud/arms/model/ARMSQueryDataSetRequest.h
View File

@@ -1,35 +1,35 @@
/*
* 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_ARMSQUERYDATASETREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_ARMSQUERYDATASETREQUEST_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 ARMSQueryDataSetRequest : public RpcServiceRequest
{
/*
* 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_ARMSQUERYDATASETREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_ARMSQUERYDATASETREQUEST_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 ARMSQueryDataSetRequest : public RpcServiceRequest
{
struct OptionalDims
{
std::string type;
@@ -48,11 +48,11 @@ namespace AlibabaCloud
std::string value;
std::string key;
};
public:
ARMSQueryDataSetRequest();
~ARMSQueryDataSetRequest();
public:
ARMSQueryDataSetRequest();
~ARMSQueryDataSetRequest();
std::string getDateStr()const;
void setDateStr(const std::string& dateStr);
long getMinTime()const;
@@ -87,8 +87,8 @@ namespace AlibabaCloud
void setDatasetId(long datasetId);
std::vector<Dimensions> getDimensions()const;
void setDimensions(const std::vector<Dimensions>& dimensions);
private:
private:
std::string dateStr_;
long minTime_;
bool reduceTail_;
@@ -106,9 +106,9 @@ namespace AlibabaCloud
std::vector<RequiredDims> requiredDims_;
long datasetId_;
std::vector<Dimensions> dimensions_;
};
}
}
}
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_ARMSQUERYDATASETREQUEST_H_

96
arms/include/alibabacloud/arms/model/ARMSQueryDataSetResult.h
View File

@@ -1,51 +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_ARMSQUERYDATASETRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_ARMSQUERYDATASETRESULT_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 ARMSQueryDataSetResult : public ServiceResult
{
public:
ARMSQueryDataSetResult();
explicit ARMSQueryDataSetResult(const std::string &payload);
~ARMSQueryDataSetResult();
/*
* 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_ARMSQUERYDATASETRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_ARMSQUERYDATASETRESULT_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 ARMSQueryDataSetResult : public ServiceResult
{
public:
ARMSQueryDataSetResult();
explicit ARMSQueryDataSetResult(const std::string &payload);
~ARMSQueryDataSetResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_ARMSQUERYDATASETRESULT_H_

51
arms/include/alibabacloud/arms/model/GetServicesRequest.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_GETSERVICESREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_GETSERVICESREQUEST_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 GetServicesRequest : public RpcServiceRequest
{
public:
GetServicesRequest();
~GetServicesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAppType()const;
void setAppType(const std::string& appType);
private:
std::string regionId_;
std::string appType_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETSERVICESREQUEST_H_

62
arms/include/alibabacloud/arms/model/GetServicesResult.h 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.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_GETSERVICESRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_GETSERVICESRESULT_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 GetServicesResult : public ServiceResult
{
public:
struct Data
{
struct DetailsItem
{
std::string serviceName;
std::string pid;
std::string regionId;
};
std::vector<std::string> services;
std::vector<DetailsItem> details;
};
GetServicesResult();
explicit GetServicesResult(const std::string &payload);
~GetServicesResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETSERVICESRESULT_H_

57
arms/include/alibabacloud/arms/model/GetSpanNamesRequest.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_GETSPANNAMESREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_GETSPANNAMESREQUEST_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 GetSpanNamesRequest : public RpcServiceRequest
{
public:
GetSpanNamesRequest();
~GetSpanNamesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
long getEndTime()const;
void setEndTime(long endTime);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
long getStartTime()const;
void setStartTime(long startTime);
private:
std::string regionId_;
long endTime_;
std::string serviceName_;
long startTime_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETSPANNAMESREQUEST_H_

51
arms/include/alibabacloud/arms/model/GetSpanNamesResult.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_GETSPANNAMESRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_GETSPANNAMESRESULT_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 GetSpanNamesResult : public ServiceResult
{
public:
GetSpanNamesResult();
explicit GetSpanNamesResult(const std::string &payload);
~GetSpanNamesResult();
std::vector<std::string> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETSPANNAMESRESULT_H_

60
arms/include/alibabacloud/arms/model/GetTagKeyRequest.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_GETTAGKEYREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_GETTAGKEYREQUEST_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 GetTagKeyRequest : public RpcServiceRequest
{
public:
GetTagKeyRequest();
~GetTagKeyRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
long getEndTime()const;
void setEndTime(long endTime);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
long getStartTime()const;
void setStartTime(long startTime);
std::string getSpanName()const;
void setSpanName(const std::string& spanName);
private:
std::string regionId_;
long endTime_;
std::string serviceName_;
long startTime_;
std::string spanName_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETTAGKEYREQUEST_H_

51
arms/include/alibabacloud/arms/model/GetTagKeyResult.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_GETTAGKEYRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_GETTAGKEYRESULT_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 GetTagKeyResult : public ServiceResult
{
public:
GetTagKeyResult();
explicit GetTagKeyResult(const std::string &payload);
~GetTagKeyResult();
std::vector<std::string> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETTAGKEYRESULT_H_

63
arms/include/alibabacloud/arms/model/GetTagValRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* 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_GETTAGVALREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_GETTAGVALREQUEST_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 GetTagValRequest : public RpcServiceRequest
{
public:
GetTagValRequest();
~GetTagValRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
long getEndTime()const;
void setEndTime(long endTime);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
long getStartTime()const;
void setStartTime(long startTime);
std::string getTagKey()const;
void setTagKey(const std::string& tagKey);
std::string getSpanName()const;
void setSpanName(const std::string& spanName);
private:
std::string regionId_;
long endTime_;
std::string serviceName_;
long startTime_;
std::string tagKey_;
std::string spanName_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETTAGVALREQUEST_H_

51
arms/include/alibabacloud/arms/model/GetTagValResult.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_GETTAGVALRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_GETTAGVALRESULT_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 GetTagValResult : public ServiceResult
{
public:
GetTagValResult();
explicit GetTagValResult(const std::string &payload);
~GetTagValResult();
std::vector<std::string> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETTAGVALRESULT_H_

54
arms/include/alibabacloud/arms/model/GetTraceRequest.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_GETTRACEREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_GETTRACEREQUEST_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 GetTraceRequest : public RpcServiceRequest
{
public:
GetTraceRequest();
~GetTraceRequest();
std::string getTraceID()const;
void setTraceID(const std::string& traceID);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAppType()const;
void setAppType(const std::string& appType);
private:
std::string traceID_;
std::string regionId_;
std::string appType_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETTRACEREQUEST_H_

80
arms/include/alibabacloud/arms/model/GetTraceResult.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* 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_GETTRACERESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_GETTRACERESULT_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 GetTraceResult : public ServiceResult
{
public:
struct CallChainInfo
{
struct TagEntry
{
std::string value;
std::string key;
};
struct LogEvent
{
struct TagEntry2
{
std::string value;
std::string key;
};
std::vector<LogEvent::TagEntry2> tagEntryList1;
long timestamp;
};
bool haveStack;
std::string serviceIp;
std::vector<CallChainInfo::LogEvent> logEventList;
std::string operationName;
std::string serviceName;
std::string rpcId;
std::string traceID;
long duration;
std::vector<CallChainInfo::TagEntry> tagEntryList;
long timestamp;
std::string resultCode;
};
GetTraceResult();
explicit GetTraceResult(const std::string &payload);
~GetTraceResult();
std::vector<CallChainInfo> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<CallChainInfo> data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_GETTRACERESULT_H_

121
arms/include/alibabacloud/arms/model/MetricQueryRequest.h
View File

@@ -1,45 +1,55 @@
/*
* 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_METRICQUERYREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_METRICQUERYREQUEST_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 MetricQueryRequest : public RpcServiceRequest
{
/*
* 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_METRICQUERYREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_METRICQUERYREQUEST_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 MetricQueryRequest : public RpcServiceRequest
{
struct Filters
{
std::string value;
std::string key;
};
public:
MetricQueryRequest();
~MetricQueryRequest();
public:
MetricQueryRequest();
~MetricQueryRequest();
long getEndTime()const;
void setEndTime(long endTime);
std::string getOrderBy()const;
void setOrderBy(const std::string& orderBy);
std::vector<Filters> getFilters()const;
void setFilters(const std::vector<Filters>& filters);
long getStartTime()const;
void setStartTime(long startTime);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
int getIintervalInSec()const;
void setIintervalInSec(int iintervalInSec);
std::vector<std::string> getMeasures()const;
@@ -48,39 +58,32 @@ namespace AlibabaCloud
void setMetric(const std::string& metric);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getLimit()const;
void setLimit(int limit);
long getEndTime()const;
void setEndTime(long endTime);
std::string getOrderBy()const;
void setOrderBy(const std::string& orderBy);
long getStartTime()const;
void setStartTime(long startTime);
std::vector<Filters> getFilters()const;
void setFilters(const std::vector<Filters>& filters);
std::vector<std::string> getDimensions()const;
void setDimensions(const std::vector<std::string>& dimensions);
std::string getOrder()const;
void setOrder(const std::string& order);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
private:
long endTime_;
std::string orderBy_;
std::vector<Filters> filters_;
long startTime_;
std::string accessKeyId_;
int iintervalInSec_;
std::vector<std::string> measures_;
std::string metric_;
std::string securityToken_;
std::string regionId_;
int limit_;
long endTime_;
std::string orderBy_;
long startTime_;
std::vector<Filters> filters_;
std::vector<std::string> dimensions_;
std::string order_;
std::string accessKeyId_;
};
}
}
}
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_METRICQUERYREQUEST_H_

96
arms/include/alibabacloud/arms/model/MetricQueryResult.h
View File

@@ -1,51 +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_METRICQUERYRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_METRICQUERYRESULT_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 MetricQueryResult : public ServiceResult
{
public:
MetricQueryResult();
explicit MetricQueryResult(const std::string &payload);
~MetricQueryResult();
/*
* 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_METRICQUERYRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_METRICQUERYRESULT_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 MetricQueryResult : public ServiceResult
{
public:
MetricQueryResult();
explicit MetricQueryResult(const std::string &payload);
~MetricQueryResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_METRICQUERYRESULT_H_

77
arms/include/alibabacloud/arms/model/SearchTraceCountRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* 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_SEARCHTRACECOUNTREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHTRACECOUNTREQUEST_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 SearchTraceCountRequest : public RpcServiceRequest
{
struct Tag
{
std::string value;
std::string key;
};
public:
SearchTraceCountRequest();
~SearchTraceCountRequest();
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOperationName()const;
void setOperationName(const std::string& operationName);
std::string getAppType()const;
void setAppType(const std::string& appType);
long getEndTime()const;
void setEndTime(long endTime);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
long getStartTime()const;
void setStartTime(long startTime);
std::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
long getMinDuration()const;
void setMinDuration(long minDuration);
private:
std::string instanceId_;
std::string regionId_;
std::string operationName_;
std::string appType_;
long endTime_;
std::string serviceName_;
long startTime_;
std::vector<Tag> tag_;
long minDuration_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHTRACECOUNTREQUEST_H_

55
arms/include/alibabacloud/arms/model/SearchTraceCountResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_SEARCHTRACECOUNTRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHTRACECOUNTRESULT_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 SearchTraceCountResult : public ServiceResult
{
public:
struct Data
{
long count;
};
SearchTraceCountResult();
explicit SearchTraceCountResult(const std::string &payload);
~SearchTraceCountResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHTRACECOUNTRESULT_H_

86
arms/include/alibabacloud/arms/model/SearchTracesRequest.h Normal file
View File

@@ -0,0 +1,86 @@
/*
* 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_SEARCHTRACESREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHTRACESREQUEST_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 SearchTracesRequest : public RpcServiceRequest
{
struct Tag
{
std::string value;
std::string key;
};
public:
SearchTracesRequest();
~SearchTracesRequest();
std::string getServiceIp()const;
void setServiceIp(const std::string& serviceIp);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOperationName()const;
void setOperationName(const std::string& operationName);
std::string getAppType()const;
void setAppType(const std::string& appType);
int getPageSize()const;
void setPageSize(int pageSize);
long getEndTime()const;
void setEndTime(long endTime);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
int getPageIndex()const;
void setPageIndex(int pageIndex);
long getStartTime()const;
void setStartTime(long startTime);
std::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
bool getReverse()const;
void setReverse(bool reverse);
long getMinDuration()const;
void setMinDuration(long minDuration);
private:
std::string serviceIp_;
std::string regionId_;
std::string operationName_;
std::string appType_;
int pageSize_;
long endTime_;
std::string serviceName_;
int pageIndex_;
long startTime_;
std::vector<Tag> tag_;
bool reverse_;
long minDuration_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHTRACESREQUEST_H_

60
arms/include/alibabacloud/arms/model/SearchTracesResult.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_SEARCHTRACESRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHTRACESRESULT_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 SearchTracesResult : public ServiceResult
{
public:
struct TraceInfo
{
std::string serviceIp;
std::string operationName;
std::string serviceName;
std::string traceID;
int duration;
long timestamp;
};
SearchTracesResult();
explicit SearchTracesResult(const std::string &payload);
~SearchTracesResult();
std::vector<TraceInfo> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<TraceInfo> data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHTRACESRESULT_H_

498
arms/src/ARMSClient.cc
View File

@@ -1,125 +1,377 @@
/*
* 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/ARMSClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
namespace
{
const std::string SERVICE_NAME = "ARMS";
}
ARMSClient::ARMSClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ARMSClient::ARMSClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ARMSClient::ARMSClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ARMSClient::~ARMSClient()
{}
ARMSClient::ARMSQueryDataSetOutcome ARMSClient::aRMSQueryDataSet(const ARMSQueryDataSetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ARMSQueryDataSetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ARMSQueryDataSetOutcome(ARMSQueryDataSetResult(outcome.result()));
else
return ARMSQueryDataSetOutcome(outcome.error());
}
void ARMSClient::aRMSQueryDataSetAsync(const ARMSQueryDataSetRequest& request, const ARMSQueryDataSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, aRMSQueryDataSet(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::ARMSQueryDataSetOutcomeCallable ARMSClient::aRMSQueryDataSetCallable(const ARMSQueryDataSetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ARMSQueryDataSetOutcome()>>(
[this, request]()
{
return this->aRMSQueryDataSet(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
/*
* 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.
*/
ARMSClient::MetricQueryOutcome ARMSClient::metricQuery(const MetricQueryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MetricQueryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MetricQueryOutcome(MetricQueryResult(outcome.result()));
else
return MetricQueryOutcome(outcome.error());
}
void ARMSClient::metricQueryAsync(const MetricQueryRequest& request, const MetricQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, metricQuery(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::MetricQueryOutcomeCallable ARMSClient::metricQueryCallable(const MetricQueryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MetricQueryOutcome()>>(
[this, request]()
{
return this->metricQuery(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
#include <alibabacloud/arms/ARMSClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
namespace
{
const std::string SERVICE_NAME = "ARMS";
}
ARMSClient::ARMSClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ARMSClient::ARMSClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ARMSClient::ARMSClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ARMSClient::~ARMSClient()
{}
ARMSClient::GetTraceOutcome ARMSClient::getTrace(const GetTraceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTraceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTraceOutcome(GetTraceResult(outcome.result()));
else
return GetTraceOutcome(outcome.error());
}
void ARMSClient::getTraceAsync(const GetTraceRequest& request, const GetTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTrace(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetTraceOutcomeCallable ARMSClient::getTraceCallable(const GetTraceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTraceOutcome()>>(
[this, request]()
{
return this->getTrace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::SearchTracesOutcome ARMSClient::searchTraces(const SearchTracesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchTracesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchTracesOutcome(SearchTracesResult(outcome.result()));
else
return SearchTracesOutcome(outcome.error());
}
void ARMSClient::searchTracesAsync(const SearchTracesRequest& request, const SearchTracesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchTraces(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::SearchTracesOutcomeCallable ARMSClient::searchTracesCallable(const SearchTracesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchTracesOutcome()>>(
[this, request]()
{
return this->searchTraces(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::SearchTraceCountOutcome ARMSClient::searchTraceCount(const SearchTraceCountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchTraceCountOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchTraceCountOutcome(SearchTraceCountResult(outcome.result()));
else
return SearchTraceCountOutcome(outcome.error());
}
void ARMSClient::searchTraceCountAsync(const SearchTraceCountRequest& request, const SearchTraceCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchTraceCount(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::SearchTraceCountOutcomeCallable ARMSClient::searchTraceCountCallable(const SearchTraceCountRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchTraceCountOutcome()>>(
[this, request]()
{
return this->searchTraceCount(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::GetTagKeyOutcome ARMSClient::getTagKey(const GetTagKeyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTagKeyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTagKeyOutcome(GetTagKeyResult(outcome.result()));
else
return GetTagKeyOutcome(outcome.error());
}
void ARMSClient::getTagKeyAsync(const GetTagKeyRequest& request, const GetTagKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTagKey(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetTagKeyOutcomeCallable ARMSClient::getTagKeyCallable(const GetTagKeyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTagKeyOutcome()>>(
[this, request]()
{
return this->getTagKey(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::ARMSQueryDataSetOutcome ARMSClient::aRMSQueryDataSet(const ARMSQueryDataSetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ARMSQueryDataSetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ARMSQueryDataSetOutcome(ARMSQueryDataSetResult(outcome.result()));
else
return ARMSQueryDataSetOutcome(outcome.error());
}
void ARMSClient::aRMSQueryDataSetAsync(const ARMSQueryDataSetRequest& request, const ARMSQueryDataSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, aRMSQueryDataSet(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::ARMSQueryDataSetOutcomeCallable ARMSClient::aRMSQueryDataSetCallable(const ARMSQueryDataSetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ARMSQueryDataSetOutcome()>>(
[this, request]()
{
return this->aRMSQueryDataSet(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::GetSpanNamesOutcome ARMSClient::getSpanNames(const GetSpanNamesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetSpanNamesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetSpanNamesOutcome(GetSpanNamesResult(outcome.result()));
else
return GetSpanNamesOutcome(outcome.error());
}
void ARMSClient::getSpanNamesAsync(const GetSpanNamesRequest& request, const GetSpanNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getSpanNames(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetSpanNamesOutcomeCallable ARMSClient::getSpanNamesCallable(const GetSpanNamesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetSpanNamesOutcome()>>(
[this, request]()
{
return this->getSpanNames(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::GetServicesOutcome ARMSClient::getServices(const GetServicesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetServicesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetServicesOutcome(GetServicesResult(outcome.result()));
else
return GetServicesOutcome(outcome.error());
}
void ARMSClient::getServicesAsync(const GetServicesRequest& request, const GetServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getServices(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetServicesOutcomeCallable ARMSClient::getServicesCallable(const GetServicesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetServicesOutcome()>>(
[this, request]()
{
return this->getServices(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::MetricQueryOutcome ARMSClient::metricQuery(const MetricQueryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MetricQueryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MetricQueryOutcome(MetricQueryResult(outcome.result()));
else
return MetricQueryOutcome(outcome.error());
}
void ARMSClient::metricQueryAsync(const MetricQueryRequest& request, const MetricQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, metricQuery(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::MetricQueryOutcomeCallable ARMSClient::metricQueryCallable(const MetricQueryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MetricQueryOutcome()>>(
[this, request]()
{
return this->metricQuery(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::GetTagValOutcome ARMSClient::getTagVal(const GetTagValRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTagValOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTagValOutcome(GetTagValResult(outcome.result()));
else
return GetTagValOutcome(outcome.error());
}
void ARMSClient::getTagValAsync(const GetTagValRequest& request, const GetTagValAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTagVal(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetTagValOutcomeCallable ARMSClient::getTagValCallable(const GetTagValRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTagValOutcome()>>(
[this, request]()
{
return this->getTagVal(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

100
arms/src/model/ARMSQueryDataSetRequest.cc
View File

@@ -1,30 +1,30 @@
/*
* 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/ARMSQueryDataSetRequest.h>
using AlibabaCloud::ARMS::Model::ARMSQueryDataSetRequest;
ARMSQueryDataSetRequest::ARMSQueryDataSetRequest() :
RpcServiceRequest("arms", "2018-10-15", "ARMSQueryDataSet")
{}
ARMSQueryDataSetRequest::~ARMSQueryDataSetRequest()
{}
/*
* 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/ARMSQueryDataSetRequest.h>
using AlibabaCloud::ARMS::Model::ARMSQueryDataSetRequest;
ARMSQueryDataSetRequest::ARMSQueryDataSetRequest() :
RpcServiceRequest("arms", "2019-02-19", "ARMSQueryDataSet")
{}
ARMSQueryDataSetRequest::~ARMSQueryDataSetRequest()
{}
std::string ARMSQueryDataSetRequest::getDateStr()const
{
return dateStr_;
@@ -33,7 +33,7 @@ std::string ARMSQueryDataSetRequest::getDateStr()const
void ARMSQueryDataSetRequest::setDateStr(const std::string& dateStr)
{
dateStr_ = dateStr;
setParameter("DateStr", dateStr);
setCoreParameter("DateStr", dateStr);
}
long ARMSQueryDataSetRequest::getMinTime()const
@@ -44,7 +44,7 @@ long ARMSQueryDataSetRequest::getMinTime()const
void ARMSQueryDataSetRequest::setMinTime(long minTime)
{
minTime_ = minTime;
setParameter("MinTime", std::to_string(minTime));
setCoreParameter("MinTime", std::to_string(minTime));
}
bool ARMSQueryDataSetRequest::getReduceTail()const
@@ -55,7 +55,7 @@ bool ARMSQueryDataSetRequest::getReduceTail()const
void ARMSQueryDataSetRequest::setReduceTail(bool reduceTail)
{
reduceTail_ = reduceTail;
setParameter("ReduceTail", std::to_string(reduceTail));
setCoreParameter("ReduceTail", reduceTail ? "true" : "false");
}
long ARMSQueryDataSetRequest::getMaxTime()const
@@ -66,7 +66,7 @@ long ARMSQueryDataSetRequest::getMaxTime()const
void ARMSQueryDataSetRequest::setMaxTime(long maxTime)
{
maxTime_ = maxTime;
setParameter("MaxTime", std::to_string(maxTime));
setCoreParameter("MaxTime", std::to_string(maxTime));
}
std::string ARMSQueryDataSetRequest::getAccessKeyId()const
@@ -77,7 +77,7 @@ std::string ARMSQueryDataSetRequest::getAccessKeyId()const
void ARMSQueryDataSetRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
setCoreParameter("AccessKeyId", accessKeyId);
}
std::vector<ARMSQueryDataSetRequest::OptionalDims> ARMSQueryDataSetRequest::getOptionalDims()const
@@ -92,9 +92,9 @@ void ARMSQueryDataSetRequest::setOptionalDims(const std::vector<OptionalDims>& o
for(int i = 0; i!= optionalDims.size(); i++) {
auto obj = optionalDims.at(i);
std::string str ="OptionalDims."+ std::to_string(i);
setParameter(str + ".Type", obj.type);
setParameter(str + ".Value", obj.value);
setParameter(str + ".Key", obj.key);
setCoreParameter(str + ".Type", obj.type);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
@@ -107,7 +107,7 @@ void ARMSQueryDataSetRequest::setMeasures(const std::vector<std::string>& measur
{
measures_ = measures;
for(int i = 0; i!= measures.size(); i++)
setParameter("Measures."+ std::to_string(i), measures.at(i));
setCoreParameter("Measures."+ std::to_string(i), measures.at(i));
}
int ARMSQueryDataSetRequest::getIntervalInSec()const
@@ -118,7 +118,7 @@ int ARMSQueryDataSetRequest::getIntervalInSec()const
void ARMSQueryDataSetRequest::setIntervalInSec(int intervalInSec)
{
intervalInSec_ = intervalInSec;
setParameter("IntervalInSec", std::to_string(intervalInSec));
setCoreParameter("IntervalInSec", std::to_string(intervalInSec));
}
bool ARMSQueryDataSetRequest::getIsDrillDown()const
@@ -129,7 +129,7 @@ bool ARMSQueryDataSetRequest::getIsDrillDown()const
void ARMSQueryDataSetRequest::setIsDrillDown(bool isDrillDown)
{
isDrillDown_ = isDrillDown;
setParameter("IsDrillDown", std::to_string(isDrillDown));
setCoreParameter("IsDrillDown", isDrillDown ? "true" : "false");
}
bool ARMSQueryDataSetRequest::getHungryMode()const
@@ -140,7 +140,7 @@ bool ARMSQueryDataSetRequest::getHungryMode()const
void ARMSQueryDataSetRequest::setHungryMode(bool hungryMode)
{
hungryMode_ = hungryMode;
setParameter("HungryMode", std::to_string(hungryMode));
setCoreParameter("HungryMode", hungryMode ? "true" : "false");
}
std::string ARMSQueryDataSetRequest::getSecurityToken()const
@@ -151,7 +151,7 @@ std::string ARMSQueryDataSetRequest::getSecurityToken()const
void ARMSQueryDataSetRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
setCoreParameter("SecurityToken", securityToken);
}
std::string ARMSQueryDataSetRequest::getRegionId()const
@@ -162,7 +162,7 @@ std::string ARMSQueryDataSetRequest::getRegionId()const
void ARMSQueryDataSetRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
setCoreParameter("RegionId", regionId);
}
std::string ARMSQueryDataSetRequest::getOrderByKey()const
@@ -173,7 +173,7 @@ std::string ARMSQueryDataSetRequest::getOrderByKey()const
void ARMSQueryDataSetRequest::setOrderByKey(const std::string& orderByKey)
{
orderByKey_ = orderByKey;
setParameter("OrderByKey", orderByKey);
setCoreParameter("OrderByKey", orderByKey);
}
int ARMSQueryDataSetRequest::getLimit()const
@@ -184,7 +184,7 @@ int ARMSQueryDataSetRequest::getLimit()const
void ARMSQueryDataSetRequest::setLimit(int limit)
{
limit_ = limit;
setParameter("Limit", std::to_string(limit));
setCoreParameter("Limit", std::to_string(limit));
}
std::vector<ARMSQueryDataSetRequest::RequiredDims> ARMSQueryDataSetRequest::getRequiredDims()const
@@ -199,9 +199,9 @@ void ARMSQueryDataSetRequest::setRequiredDims(const std::vector<RequiredDims>& r
for(int i = 0; i!= requiredDims.size(); i++) {
auto obj = requiredDims.at(i);
std::string str ="RequiredDims."+ std::to_string(i);
setParameter(str + ".Type", obj.type);
setParameter(str + ".Value", obj.value);
setParameter(str + ".Key", obj.key);
setCoreParameter(str + ".Type", obj.type);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
@@ -213,7 +213,7 @@ long ARMSQueryDataSetRequest::getDatasetId()const
void ARMSQueryDataSetRequest::setDatasetId(long datasetId)
{
datasetId_ = datasetId;
setParameter("DatasetId", std::to_string(datasetId));
setCoreParameter("DatasetId", std::to_string(datasetId));
}
std::vector<ARMSQueryDataSetRequest::Dimensions> ARMSQueryDataSetRequest::getDimensions()const
@@ -228,9 +228,9 @@ void ARMSQueryDataSetRequest::setDimensions(const std::vector<Dimensions>& dimen
for(int i = 0; i!= dimensions.size(); i++) {
auto obj = dimensions.at(i);
std::string str ="Dimensions."+ std::to_string(i);
setParameter(str + ".Type", obj.type);
setParameter(str + ".Value", obj.value);
setParameter(str + ".Key", obj.key);
setCoreParameter(str + ".Type", obj.type);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}

90
arms/src/model/ARMSQueryDataSetResult.cc
View File

@@ -1,50 +1,50 @@
/*
* 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/ARMSQueryDataSetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
ARMSQueryDataSetResult::ARMSQueryDataSetResult() :
ServiceResult()
{}
ARMSQueryDataSetResult::ARMSQueryDataSetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ARMSQueryDataSetResult::~ARMSQueryDataSetResult()
{}
void ARMSQueryDataSetResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
/*
* 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/ARMSQueryDataSetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
ARMSQueryDataSetResult::ARMSQueryDataSetResult() :
ServiceResult()
{}
ARMSQueryDataSetResult::ARMSQueryDataSetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ARMSQueryDataSetResult::~ARMSQueryDataSetResult()
{}
void ARMSQueryDataSetResult::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 ARMSQueryDataSetResult::getData()const
{
return data_;

49
arms/src/model/GetServicesRequest.cc Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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/GetServicesRequest.h>
using AlibabaCloud::ARMS::Model::GetServicesRequest;
GetServicesRequest::GetServicesRequest() :
RpcServiceRequest("arms", "2019-02-19", "GetServices")
{}
GetServicesRequest::~GetServicesRequest()
{}
std::string GetServicesRequest::getRegionId()const
{
return regionId_;
}
void GetServicesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string GetServicesRequest::getAppType()const
{
return appType_;
}
void GetServicesRequest::setAppType(const std::string& appType)
{
appType_ = appType;
setCoreParameter("AppType", appType);
}

66
arms/src/model/GetServicesResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/GetServicesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
GetServicesResult::GetServicesResult() :
ServiceResult()
{}
GetServicesResult::GetServicesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetServicesResult::~GetServicesResult()
{}
void GetServicesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allDetails = value["Details"]["DetailsItem"];
for (auto value : allDetails)
{
Data::DetailsItem detailsItemObject;
if(!value["ServiceName"].isNull())
detailsItemObject.serviceName = value["ServiceName"].asString();
if(!value["Pid"].isNull())
detailsItemObject.pid = value["Pid"].asString();
if(!value["RegionId"].isNull())
detailsItemObject.regionId = value["RegionId"].asString();
data_.details.push_back(detailsItemObject);
}
auto allServices = dataNode["Services"]["Services"];
for (auto value : allServices)
data_.services.push_back(value.asString());
}
GetServicesResult::Data GetServicesResult::getData()const
{
return data_;
}

71
arms/src/model/GetSpanNamesRequest.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/GetSpanNamesRequest.h>
using AlibabaCloud::ARMS::Model::GetSpanNamesRequest;
GetSpanNamesRequest::GetSpanNamesRequest() :
RpcServiceRequest("arms", "2019-02-19", "GetSpanNames")
{}
GetSpanNamesRequest::~GetSpanNamesRequest()
{}
std::string GetSpanNamesRequest::getRegionId()const
{
return regionId_;
}
void GetSpanNamesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
long GetSpanNamesRequest::getEndTime()const
{
return endTime_;
}
void GetSpanNamesRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setCoreParameter("EndTime", std::to_string(endTime));
}
std::string GetSpanNamesRequest::getServiceName()const
{
return serviceName_;
}
void GetSpanNamesRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setCoreParameter("ServiceName", serviceName);
}
long GetSpanNamesRequest::getStartTime()const
{
return startTime_;
}
void GetSpanNamesRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setCoreParameter("StartTime", std::to_string(startTime));
}

53
arms/src/model/GetSpanNamesResult.cc Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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/GetSpanNamesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
GetSpanNamesResult::GetSpanNamesResult() :
ServiceResult()
{}
GetSpanNamesResult::GetSpanNamesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetSpanNamesResult::~GetSpanNamesResult()
{}
void GetSpanNamesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allData = value["Data"]["Data"];
for (const auto &item : allData)
data_.push_back(item.asString());
}
std::vector<std::string> GetSpanNamesResult::getData()const
{
return data_;
}

82
arms/src/model/GetTagKeyRequest.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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/GetTagKeyRequest.h>
using AlibabaCloud::ARMS::Model::GetTagKeyRequest;
GetTagKeyRequest::GetTagKeyRequest() :
RpcServiceRequest("arms", "2019-02-19", "GetTagKey")
{}
GetTagKeyRequest::~GetTagKeyRequest()
{}
std::string GetTagKeyRequest::getRegionId()const
{
return regionId_;
}
void GetTagKeyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
long GetTagKeyRequest::getEndTime()const
{
return endTime_;
}
void GetTagKeyRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setCoreParameter("EndTime", std::to_string(endTime));
}
std::string GetTagKeyRequest::getServiceName()const
{
return serviceName_;
}
void GetTagKeyRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setCoreParameter("ServiceName", serviceName);
}
long GetTagKeyRequest::getStartTime()const
{
return startTime_;
}
void GetTagKeyRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setCoreParameter("StartTime", std::to_string(startTime));
}
std::string GetTagKeyRequest::getSpanName()const
{
return spanName_;
}
void GetTagKeyRequest::setSpanName(const std::string& spanName)
{
spanName_ = spanName;
setCoreParameter("SpanName", spanName);
}

53
arms/src/model/GetTagKeyResult.cc Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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/GetTagKeyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
GetTagKeyResult::GetTagKeyResult() :
ServiceResult()
{}
GetTagKeyResult::GetTagKeyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetTagKeyResult::~GetTagKeyResult()
{}
void GetTagKeyResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allData = value["Data"]["Data"];
for (const auto &item : allData)
data_.push_back(item.asString());
}
std::vector<std::string> GetTagKeyResult::getData()const
{
return data_;
}

93
arms/src/model/GetTagValRequest.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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/GetTagValRequest.h>
using AlibabaCloud::ARMS::Model::GetTagValRequest;
GetTagValRequest::GetTagValRequest() :
RpcServiceRequest("arms", "2019-02-19", "GetTagVal")
{}
GetTagValRequest::~GetTagValRequest()
{}
std::string GetTagValRequest::getRegionId()const
{
return regionId_;
}
void GetTagValRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
long GetTagValRequest::getEndTime()const
{
return endTime_;
}
void GetTagValRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setCoreParameter("EndTime", std::to_string(endTime));
}
std::string GetTagValRequest::getServiceName()const
{
return serviceName_;
}
void GetTagValRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setCoreParameter("ServiceName", serviceName);
}
long GetTagValRequest::getStartTime()const
{
return startTime_;
}
void GetTagValRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setCoreParameter("StartTime", std::to_string(startTime));
}
std::string GetTagValRequest::getTagKey()const
{
return tagKey_;
}
void GetTagValRequest::setTagKey(const std::string& tagKey)
{
tagKey_ = tagKey;
setCoreParameter("TagKey", tagKey);
}
std::string GetTagValRequest::getSpanName()const
{
return spanName_;
}
void GetTagValRequest::setSpanName(const std::string& spanName)
{
spanName_ = spanName;
setCoreParameter("SpanName", spanName);
}

53
arms/src/model/GetTagValResult.cc Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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/GetTagValResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
GetTagValResult::GetTagValResult() :
ServiceResult()
{}
GetTagValResult::GetTagValResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetTagValResult::~GetTagValResult()
{}
void GetTagValResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allData = value["Data"]["Data"];
for (const auto &item : allData)
data_.push_back(item.asString());
}
std::vector<std::string> GetTagValResult::getData()const
{
return data_;
}

60
arms/src/model/GetTraceRequest.cc 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.
*/
#include <alibabacloud/arms/model/GetTraceRequest.h>
using AlibabaCloud::ARMS::Model::GetTraceRequest;
GetTraceRequest::GetTraceRequest() :
RpcServiceRequest("arms", "2019-02-19", "GetTrace")
{}
GetTraceRequest::~GetTraceRequest()
{}
std::string GetTraceRequest::getTraceID()const
{
return traceID_;
}
void GetTraceRequest::setTraceID(const std::string& traceID)
{
traceID_ = traceID;
setCoreParameter("TraceID", traceID);
}
std::string GetTraceRequest::getRegionId()const
{
return regionId_;
}
void GetTraceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string GetTraceRequest::getAppType()const
{
return appType_;
}
void GetTraceRequest::setAppType(const std::string& appType)
{
appType_ = appType;
setCoreParameter("AppType", appType);
}

102
arms/src/model/GetTraceResult.cc Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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/GetTraceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
GetTraceResult::GetTraceResult() :
ServiceResult()
{}
GetTraceResult::GetTraceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetTraceResult::~GetTraceResult()
{}
void GetTraceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allData = value["Data"]["CallChainInfo"];
for (auto value : allData)
{
CallChainInfo dataObject;
if(!value["TraceID"].isNull())
dataObject.traceID = value["TraceID"].asString();
if(!value["OperationName"].isNull())
dataObject.operationName = value["OperationName"].asString();
if(!value["Duration"].isNull())
dataObject.duration = std::stol(value["Duration"].asString());
if(!value["ServiceName"].isNull())
dataObject.serviceName = value["ServiceName"].asString();
if(!value["ServiceIp"].isNull())
dataObject.serviceIp = value["ServiceIp"].asString();
if(!value["Timestamp"].isNull())
dataObject.timestamp = std::stol(value["Timestamp"].asString());
if(!value["RpcId"].isNull())
dataObject.rpcId = value["RpcId"].asString();
if(!value["ResultCode"].isNull())
dataObject.resultCode = value["ResultCode"].asString();
if(!value["HaveStack"].isNull())
dataObject.haveStack = value["HaveStack"].asString() == "true";
auto allTagEntryList = value["TagEntryList"]["TagEntry"];
for (auto value : allTagEntryList)
{
CallChainInfo::TagEntry tagEntryListObject;
if(!value["Key"].isNull())
tagEntryListObject.key = value["Key"].asString();
if(!value["Value"].isNull())
tagEntryListObject.value = value["Value"].asString();
dataObject.tagEntryList.push_back(tagEntryListObject);
}
auto allLogEventList = value["LogEventList"]["LogEvent"];
for (auto value : allLogEventList)
{
CallChainInfo::LogEvent logEventListObject;
if(!value["Timestamp"].isNull())
logEventListObject.timestamp = std::stol(value["Timestamp"].asString());
auto allTagEntryList1 = value["TagEntryList"]["TagEntry"];
for (auto value : allTagEntryList1)
{
CallChainInfo::LogEvent::TagEntry2 tagEntryList1Object;
if(!value["Key"].isNull())
tagEntryList1Object.key = value["Key"].asString();
if(!value["Value"].isNull())
tagEntryList1Object.value = value["Value"].asString();
logEventListObject.tagEntryList1.push_back(tagEntryList1Object);
}
dataObject.logEventList.push_back(logEventListObject);
}
data_.push_back(dataObject);
}
}
std::vector<GetTraceResult::CallChainInfo> GetTraceResult::getData()const
{
return data_;
}

223
arms/src/model/MetricQueryRequest.cc
View File

@@ -1,85 +1,29 @@
/*
* 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/MetricQueryRequest.h>
using AlibabaCloud::ARMS::Model::MetricQueryRequest;
MetricQueryRequest::MetricQueryRequest() :
RpcServiceRequest("arms", "2018-10-15", "MetricQuery")
{}
MetricQueryRequest::~MetricQueryRequest()
{}
int MetricQueryRequest::getIintervalInSec()const
{
return iintervalInSec_;
}
/*
* 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.
*/
void MetricQueryRequest::setIintervalInSec(int iintervalInSec)
{
iintervalInSec_ = iintervalInSec;
setParameter("IintervalInSec", std::to_string(iintervalInSec));
}
#include <alibabacloud/arms/model/MetricQueryRequest.h>
std::vector<std::string> MetricQueryRequest::getMeasures()const
{
return measures_;
}
using AlibabaCloud::ARMS::Model::MetricQueryRequest;
void MetricQueryRequest::setMeasures(const std::vector<std::string>& measures)
{
measures_ = measures;
for(int i = 0; i!= measures.size(); i++)
setParameter("Measures."+ std::to_string(i), measures.at(i));
}
MetricQueryRequest::MetricQueryRequest() :
RpcServiceRequest("arms", "2019-02-19", "MetricQuery")
{}
std::string MetricQueryRequest::getMetric()const
{
return metric_;
}
void MetricQueryRequest::setMetric(const std::string& metric)
{
metric_ = metric;
setParameter("Metric", metric);
}
std::string MetricQueryRequest::getSecurityToken()const
{
return securityToken_;
}
void MetricQueryRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
int MetricQueryRequest::getLimit()const
{
return limit_;
}
void MetricQueryRequest::setLimit(int limit)
{
limit_ = limit;
setParameter("Limit", std::to_string(limit));
}
MetricQueryRequest::~MetricQueryRequest()
{}
long MetricQueryRequest::getEndTime()const
{
@@ -89,7 +33,7 @@ long MetricQueryRequest::getEndTime()const
void MetricQueryRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setParameter("EndTime", std::to_string(endTime));
setCoreParameter("EndTime", std::to_string(endTime));
}
std::string MetricQueryRequest::getOrderBy()const
@@ -100,18 +44,7 @@ std::string MetricQueryRequest::getOrderBy()const
void MetricQueryRequest::setOrderBy(const std::string& orderBy)
{
orderBy_ = orderBy;
setParameter("OrderBy", orderBy);
}
long MetricQueryRequest::getStartTime()const
{
return startTime_;
}
void MetricQueryRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setParameter("StartTime", std::to_string(startTime));
setCoreParameter("OrderBy", orderBy);
}
std::vector<MetricQueryRequest::Filters> MetricQueryRequest::getFilters()const
@@ -126,11 +59,100 @@ void MetricQueryRequest::setFilters(const std::vector<Filters>& filters)
for(int i = 0; i!= filters.size(); i++) {
auto obj = filters.at(i);
std::string str ="Filters."+ std::to_string(i);
setParameter(str + ".Value", obj.value);
setParameter(str + ".Key", obj.key);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
long MetricQueryRequest::getStartTime()const
{
return startTime_;
}
void MetricQueryRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setCoreParameter("StartTime", std::to_string(startTime));
}
std::string MetricQueryRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void MetricQueryRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
int MetricQueryRequest::getIintervalInSec()const
{
return iintervalInSec_;
}
void MetricQueryRequest::setIintervalInSec(int iintervalInSec)
{
iintervalInSec_ = iintervalInSec;
setCoreParameter("IintervalInSec", std::to_string(iintervalInSec));
}
std::vector<std::string> MetricQueryRequest::getMeasures()const
{
return measures_;
}
void MetricQueryRequest::setMeasures(const std::vector<std::string>& measures)
{
measures_ = measures;
for(int i = 0; i!= measures.size(); i++)
setCoreParameter("Measures."+ std::to_string(i), measures.at(i));
}
std::string MetricQueryRequest::getMetric()const
{
return metric_;
}
void MetricQueryRequest::setMetric(const std::string& metric)
{
metric_ = metric;
setCoreParameter("Metric", metric);
}
std::string MetricQueryRequest::getSecurityToken()const
{
return securityToken_;
}
void MetricQueryRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string MetricQueryRequest::getRegionId()const
{
return regionId_;
}
void MetricQueryRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
int MetricQueryRequest::getLimit()const
{
return limit_;
}
void MetricQueryRequest::setLimit(int limit)
{
limit_ = limit;
setCoreParameter("Limit", std::to_string(limit));
}
std::vector<std::string> MetricQueryRequest::getDimensions()const
{
return dimensions_;
@@ -140,7 +162,7 @@ void MetricQueryRequest::setDimensions(const std::vector<std::string>& dimension
{
dimensions_ = dimensions;
for(int i = 0; i!= dimensions.size(); i++)
setParameter("Dimensions."+ std::to_string(i), dimensions.at(i));
setCoreParameter("Dimensions."+ std::to_string(i), dimensions.at(i));
}
std::string MetricQueryRequest::getOrder()const
@@ -151,17 +173,6 @@ std::string MetricQueryRequest::getOrder()const
void MetricQueryRequest::setOrder(const std::string& order)
{
order_ = order;
setParameter("Order", order);
}
std::string MetricQueryRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void MetricQueryRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
setCoreParameter("Order", order);
}

90
arms/src/model/MetricQueryResult.cc
View File

@@ -1,50 +1,50 @@
/*
* 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/MetricQueryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
MetricQueryResult::MetricQueryResult() :
ServiceResult()
{}
MetricQueryResult::MetricQueryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
MetricQueryResult::~MetricQueryResult()
{}
void MetricQueryResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
/*
* 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/MetricQueryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
MetricQueryResult::MetricQueryResult() :
ServiceResult()
{}
MetricQueryResult::MetricQueryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
MetricQueryResult::~MetricQueryResult()
{}
void MetricQueryResult::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 MetricQueryResult::getData()const
{
return data_;

132
arms/src/model/SearchTraceCountRequest.cc Normal file
View File

@@ -0,0 +1,132 @@
/*
* 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/SearchTraceCountRequest.h>
using AlibabaCloud::ARMS::Model::SearchTraceCountRequest;
SearchTraceCountRequest::SearchTraceCountRequest() :
RpcServiceRequest("arms", "2019-02-19", "SearchTraceCount")
{}
SearchTraceCountRequest::~SearchTraceCountRequest()
{}
std::string SearchTraceCountRequest::getInstanceId()const
{
return instanceId_;
}
void SearchTraceCountRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setCoreParameter("InstanceId", instanceId);
}
std::string SearchTraceCountRequest::getRegionId()const
{
return regionId_;
}
void SearchTraceCountRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string SearchTraceCountRequest::getOperationName()const
{
return operationName_;
}
void SearchTraceCountRequest::setOperationName(const std::string& operationName)
{
operationName_ = operationName;
setCoreParameter("OperationName", operationName);
}
std::string SearchTraceCountRequest::getAppType()const
{
return appType_;
}
void SearchTraceCountRequest::setAppType(const std::string& appType)
{
appType_ = appType;
setCoreParameter("AppType", appType);
}
long SearchTraceCountRequest::getEndTime()const
{
return endTime_;
}
void SearchTraceCountRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setCoreParameter("EndTime", std::to_string(endTime));
}
std::string SearchTraceCountRequest::getServiceName()const
{
return serviceName_;
}
void SearchTraceCountRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setCoreParameter("ServiceName", serviceName);
}
long SearchTraceCountRequest::getStartTime()const
{
return startTime_;
}
void SearchTraceCountRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setCoreParameter("StartTime", std::to_string(startTime));
}
std::vector<SearchTraceCountRequest::Tag> SearchTraceCountRequest::getTag()const
{
return tag_;
}
void SearchTraceCountRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
int i = 0;
for(int i = 0; i!= tag.size(); i++) {
auto obj = tag.at(i);
std::string str ="Tag."+ std::to_string(i);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
long SearchTraceCountRequest::getMinDuration()const
{
return minDuration_;
}
void SearchTraceCountRequest::setMinDuration(long minDuration)
{
minDuration_ = minDuration;
setCoreParameter("MinDuration", std::to_string(minDuration));
}

53
arms/src/model/SearchTraceCountResult.cc Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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/SearchTraceCountResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
SearchTraceCountResult::SearchTraceCountResult() :
ServiceResult()
{}
SearchTraceCountResult::SearchTraceCountResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchTraceCountResult::~SearchTraceCountResult()
{}
void SearchTraceCountResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Count"].isNull())
data_.count = std::stol(dataNode["Count"].asString());
}
SearchTraceCountResult::Data SearchTraceCountResult::getData()const
{
return data_;
}

165
arms/src/model/SearchTracesRequest.cc Normal file
View File

@@ -0,0 +1,165 @@
/*
* 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/SearchTracesRequest.h>
using AlibabaCloud::ARMS::Model::SearchTracesRequest;
SearchTracesRequest::SearchTracesRequest() :
RpcServiceRequest("arms", "2019-02-19", "SearchTraces")
{}
SearchTracesRequest::~SearchTracesRequest()
{}
std::string SearchTracesRequest::getServiceIp()const
{
return serviceIp_;
}
void SearchTracesRequest::setServiceIp(const std::string& serviceIp)
{
serviceIp_ = serviceIp;
setCoreParameter("ServiceIp", serviceIp);
}
std::string SearchTracesRequest::getRegionId()const
{
return regionId_;
}
void SearchTracesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string SearchTracesRequest::getOperationName()const
{
return operationName_;
}
void SearchTracesRequest::setOperationName(const std::string& operationName)
{
operationName_ = operationName;
setCoreParameter("OperationName", operationName);
}
std::string SearchTracesRequest::getAppType()const
{
return appType_;
}
void SearchTracesRequest::setAppType(const std::string& appType)
{
appType_ = appType;
setCoreParameter("AppType", appType);
}
int SearchTracesRequest::getPageSize()const
{
return pageSize_;
}
void SearchTracesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
long SearchTracesRequest::getEndTime()const
{
return endTime_;
}
void SearchTracesRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setCoreParameter("EndTime", std::to_string(endTime));
}
std::string SearchTracesRequest::getServiceName()const
{
return serviceName_;
}
void SearchTracesRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setCoreParameter("ServiceName", serviceName);
}
int SearchTracesRequest::getPageIndex()const
{
return pageIndex_;
}
void SearchTracesRequest::setPageIndex(int pageIndex)
{
pageIndex_ = pageIndex;
setCoreParameter("PageIndex", std::to_string(pageIndex));
}
long SearchTracesRequest::getStartTime()const
{
return startTime_;
}
void SearchTracesRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setCoreParameter("StartTime", std::to_string(startTime));
}
std::vector<SearchTracesRequest::Tag> SearchTracesRequest::getTag()const
{
return tag_;
}
void SearchTracesRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
int i = 0;
for(int i = 0; i!= tag.size(); i++) {
auto obj = tag.at(i);
std::string str ="Tag."+ std::to_string(i);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
bool SearchTracesRequest::getReverse()const
{
return reverse_;
}
void SearchTracesRequest::setReverse(bool reverse)
{
reverse_ = reverse;
setCoreParameter("Reverse", reverse ? "true" : "false");
}
long SearchTracesRequest::getMinDuration()const
{
return minDuration_;
}
void SearchTracesRequest::setMinDuration(long minDuration)
{
minDuration_ = minDuration;
setCoreParameter("MinDuration", std::to_string(minDuration));
}

68
arms/src/model/SearchTracesResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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/SearchTracesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
SearchTracesResult::SearchTracesResult() :
ServiceResult()
{}
SearchTracesResult::SearchTracesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchTracesResult::~SearchTracesResult()
{}
void SearchTracesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allData = value["Data"]["TraceInfo"];
for (auto value : allData)
{
TraceInfo dataObject;
if(!value["TraceID"].isNull())
dataObject.traceID = value["TraceID"].asString();
if(!value["OperationName"].isNull())
dataObject.operationName = value["OperationName"].asString();
if(!value["Duration"].isNull())
dataObject.duration = std::stoi(value["Duration"].asString());
if(!value["ServiceName"].isNull())
dataObject.serviceName = value["ServiceName"].asString();
if(!value["ServiceIp"].isNull())
dataObject.serviceIp = value["ServiceIp"].asString();
if(!value["Timestamp"].isNull())
dataObject.timestamp = std::stol(value["Timestamp"].asString());
data_.push_back(dataObject);
}
}
std::vector<SearchTracesResult::TraceInfo> SearchTracesResult::getData()const
{
return data_;
}