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

Publish Api：GetNisNetworkRanking

Browse Source
This commit is contained in:
sdk-team
2024-07-04 11:37:09 +00:00
parent ef538b5d54
commit fd5e85ebf9
53 changed files with 5040 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1947
1.36.1948

130
nis/CMakeLists.txt Normal file
View File

@@ -0,0 +1,130 @@
#
# 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(nis_public_header
include/alibabacloud/nis/NisClient.h
include/alibabacloud/nis/NisExport.h )
set(nis_public_header_model
include/alibabacloud/nis/model/CreateAndAnalyzeNetworkPathRequest.h
include/alibabacloud/nis/model/CreateAndAnalyzeNetworkPathResult.h
include/alibabacloud/nis/model/CreateNetworkPathRequest.h
include/alibabacloud/nis/model/CreateNetworkPathResult.h
include/alibabacloud/nis/model/CreateNetworkReachableAnalysisRequest.h
include/alibabacloud/nis/model/CreateNetworkReachableAnalysisResult.h
include/alibabacloud/nis/model/DeleteNetworkPathRequest.h
include/alibabacloud/nis/model/DeleteNetworkPathResult.h
include/alibabacloud/nis/model/DeleteNetworkReachableAnalysisRequest.h
include/alibabacloud/nis/model/DeleteNetworkReachableAnalysisResult.h
include/alibabacloud/nis/model/GetInternetTupleRequest.h
include/alibabacloud/nis/model/GetInternetTupleResult.h
include/alibabacloud/nis/model/GetNatTopNRequest.h
include/alibabacloud/nis/model/GetNatTopNResult.h
include/alibabacloud/nis/model/GetNetworkReachableAnalysisRequest.h
include/alibabacloud/nis/model/GetNetworkReachableAnalysisResult.h
include/alibabacloud/nis/model/GetNisNetworkMetricsRequest.h
include/alibabacloud/nis/model/GetNisNetworkMetricsResult.h
include/alibabacloud/nis/model/GetNisNetworkRankingRequest.h
include/alibabacloud/nis/model/GetNisNetworkRankingResult.h
include/alibabacloud/nis/model/GetTransitRouterFlowTopNRequest.h
include/alibabacloud/nis/model/GetTransitRouterFlowTopNResult.h
include/alibabacloud/nis/model/GetVbrFlowTopNRequest.h
include/alibabacloud/nis/model/GetVbrFlowTopNResult.h )
set(nis_src
src/NisClient.cc
src/model/CreateAndAnalyzeNetworkPathRequest.cc
src/model/CreateAndAnalyzeNetworkPathResult.cc
src/model/CreateNetworkPathRequest.cc
src/model/CreateNetworkPathResult.cc
src/model/CreateNetworkReachableAnalysisRequest.cc
src/model/CreateNetworkReachableAnalysisResult.cc
src/model/DeleteNetworkPathRequest.cc
src/model/DeleteNetworkPathResult.cc
src/model/DeleteNetworkReachableAnalysisRequest.cc
src/model/DeleteNetworkReachableAnalysisResult.cc
src/model/GetInternetTupleRequest.cc
src/model/GetInternetTupleResult.cc
src/model/GetNatTopNRequest.cc
src/model/GetNatTopNResult.cc
src/model/GetNetworkReachableAnalysisRequest.cc
src/model/GetNetworkReachableAnalysisResult.cc
src/model/GetNisNetworkMetricsRequest.cc
src/model/GetNisNetworkMetricsResult.cc
src/model/GetNisNetworkRankingRequest.cc
src/model/GetNisNetworkRankingResult.cc
src/model/GetTransitRouterFlowTopNRequest.cc
src/model/GetTransitRouterFlowTopNResult.cc
src/model/GetVbrFlowTopNRequest.cc
src/model/GetVbrFlowTopNResult.cc )
add_library(nis ${LIB_TYPE}
${nis_public_header}
${nis_public_header_model}
${nis_src})
set_target_properties(nis
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}nis
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(nis
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_NIS_LIBRARY)
endif()
target_include_directories(nis
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(nis
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(nis
jsoncpp)
target_include_directories(nis
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(nis
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(nis
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(nis
PRIVATE /usr/include/jsoncpp)
target_link_libraries(nis
jsoncpp)
endif()
install(FILES ${nis_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/nis)
install(FILES ${nis_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/nis/model)
install(TARGETS nis
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

142
nis/include/alibabacloud/nis/NisClient.h Normal file
View File

@@ -0,0 +1,142 @@
/*
* 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_NIS_NISCLIENT_H_
#define ALIBABACLOUD_NIS_NISCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "NisExport.h"
#include "model/CreateAndAnalyzeNetworkPathRequest.h"
#include "model/CreateAndAnalyzeNetworkPathResult.h"
#include "model/CreateNetworkPathRequest.h"
#include "model/CreateNetworkPathResult.h"
#include "model/CreateNetworkReachableAnalysisRequest.h"
#include "model/CreateNetworkReachableAnalysisResult.h"
#include "model/DeleteNetworkPathRequest.h"
#include "model/DeleteNetworkPathResult.h"
#include "model/DeleteNetworkReachableAnalysisRequest.h"
#include "model/DeleteNetworkReachableAnalysisResult.h"
#include "model/GetInternetTupleRequest.h"
#include "model/GetInternetTupleResult.h"
#include "model/GetNatTopNRequest.h"
#include "model/GetNatTopNResult.h"
#include "model/GetNetworkReachableAnalysisRequest.h"
#include "model/GetNetworkReachableAnalysisResult.h"
#include "model/GetNisNetworkMetricsRequest.h"
#include "model/GetNisNetworkMetricsResult.h"
#include "model/GetNisNetworkRankingRequest.h"
#include "model/GetNisNetworkRankingResult.h"
#include "model/GetTransitRouterFlowTopNRequest.h"
#include "model/GetTransitRouterFlowTopNResult.h"
#include "model/GetVbrFlowTopNRequest.h"
#include "model/GetVbrFlowTopNResult.h"
namespace AlibabaCloud
{
namespace Nis
{
class ALIBABACLOUD_NIS_EXPORT NisClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CreateAndAnalyzeNetworkPathResult> CreateAndAnalyzeNetworkPathOutcome;
typedef std::future<CreateAndAnalyzeNetworkPathOutcome> CreateAndAnalyzeNetworkPathOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::CreateAndAnalyzeNetworkPathRequest&, const CreateAndAnalyzeNetworkPathOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAndAnalyzeNetworkPathAsyncHandler;
typedef Outcome<Error, Model::CreateNetworkPathResult> CreateNetworkPathOutcome;
typedef std::future<CreateNetworkPathOutcome> CreateNetworkPathOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::CreateNetworkPathRequest&, const CreateNetworkPathOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNetworkPathAsyncHandler;
typedef Outcome<Error, Model::CreateNetworkReachableAnalysisResult> CreateNetworkReachableAnalysisOutcome;
typedef std::future<CreateNetworkReachableAnalysisOutcome> CreateNetworkReachableAnalysisOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::CreateNetworkReachableAnalysisRequest&, const CreateNetworkReachableAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNetworkReachableAnalysisAsyncHandler;
typedef Outcome<Error, Model::DeleteNetworkPathResult> DeleteNetworkPathOutcome;
typedef std::future<DeleteNetworkPathOutcome> DeleteNetworkPathOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::DeleteNetworkPathRequest&, const DeleteNetworkPathOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNetworkPathAsyncHandler;
typedef Outcome<Error, Model::DeleteNetworkReachableAnalysisResult> DeleteNetworkReachableAnalysisOutcome;
typedef std::future<DeleteNetworkReachableAnalysisOutcome> DeleteNetworkReachableAnalysisOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::DeleteNetworkReachableAnalysisRequest&, const DeleteNetworkReachableAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNetworkReachableAnalysisAsyncHandler;
typedef Outcome<Error, Model::GetInternetTupleResult> GetInternetTupleOutcome;
typedef std::future<GetInternetTupleOutcome> GetInternetTupleOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::GetInternetTupleRequest&, const GetInternetTupleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInternetTupleAsyncHandler;
typedef Outcome<Error, Model::GetNatTopNResult> GetNatTopNOutcome;
typedef std::future<GetNatTopNOutcome> GetNatTopNOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::GetNatTopNRequest&, const GetNatTopNOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNatTopNAsyncHandler;
typedef Outcome<Error, Model::GetNetworkReachableAnalysisResult> GetNetworkReachableAnalysisOutcome;
typedef std::future<GetNetworkReachableAnalysisOutcome> GetNetworkReachableAnalysisOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::GetNetworkReachableAnalysisRequest&, const GetNetworkReachableAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNetworkReachableAnalysisAsyncHandler;
typedef Outcome<Error, Model::GetNisNetworkMetricsResult> GetNisNetworkMetricsOutcome;
typedef std::future<GetNisNetworkMetricsOutcome> GetNisNetworkMetricsOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::GetNisNetworkMetricsRequest&, const GetNisNetworkMetricsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNisNetworkMetricsAsyncHandler;
typedef Outcome<Error, Model::GetNisNetworkRankingResult> GetNisNetworkRankingOutcome;
typedef std::future<GetNisNetworkRankingOutcome> GetNisNetworkRankingOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::GetNisNetworkRankingRequest&, const GetNisNetworkRankingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNisNetworkRankingAsyncHandler;
typedef Outcome<Error, Model::GetTransitRouterFlowTopNResult> GetTransitRouterFlowTopNOutcome;
typedef std::future<GetTransitRouterFlowTopNOutcome> GetTransitRouterFlowTopNOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::GetTransitRouterFlowTopNRequest&, const GetTransitRouterFlowTopNOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTransitRouterFlowTopNAsyncHandler;
typedef Outcome<Error, Model::GetVbrFlowTopNResult> GetVbrFlowTopNOutcome;
typedef std::future<GetVbrFlowTopNOutcome> GetVbrFlowTopNOutcomeCallable;
typedef std::function<void(const NisClient*, const Model::GetVbrFlowTopNRequest&, const GetVbrFlowTopNOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVbrFlowTopNAsyncHandler;
NisClient(const Credentials &credentials, const ClientConfiguration &configuration);
NisClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
NisClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~NisClient();
CreateAndAnalyzeNetworkPathOutcome createAndAnalyzeNetworkPath(const Model::CreateAndAnalyzeNetworkPathRequest &request)const;
void createAndAnalyzeNetworkPathAsync(const Model::CreateAndAnalyzeNetworkPathRequest& request, const CreateAndAnalyzeNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAndAnalyzeNetworkPathOutcomeCallable createAndAnalyzeNetworkPathCallable(const Model::CreateAndAnalyzeNetworkPathRequest& request) const;
CreateNetworkPathOutcome createNetworkPath(const Model::CreateNetworkPathRequest &request)const;
void createNetworkPathAsync(const Model::CreateNetworkPathRequest& request, const CreateNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateNetworkPathOutcomeCallable createNetworkPathCallable(const Model::CreateNetworkPathRequest& request) const;
CreateNetworkReachableAnalysisOutcome createNetworkReachableAnalysis(const Model::CreateNetworkReachableAnalysisRequest &request)const;
void createNetworkReachableAnalysisAsync(const Model::CreateNetworkReachableAnalysisRequest& request, const CreateNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateNetworkReachableAnalysisOutcomeCallable createNetworkReachableAnalysisCallable(const Model::CreateNetworkReachableAnalysisRequest& request) const;
DeleteNetworkPathOutcome deleteNetworkPath(const Model::DeleteNetworkPathRequest &request)const;
void deleteNetworkPathAsync(const Model::DeleteNetworkPathRequest& request, const DeleteNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteNetworkPathOutcomeCallable deleteNetworkPathCallable(const Model::DeleteNetworkPathRequest& request) const;
DeleteNetworkReachableAnalysisOutcome deleteNetworkReachableAnalysis(const Model::DeleteNetworkReachableAnalysisRequest &request)const;
void deleteNetworkReachableAnalysisAsync(const Model::DeleteNetworkReachableAnalysisRequest& request, const DeleteNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteNetworkReachableAnalysisOutcomeCallable deleteNetworkReachableAnalysisCallable(const Model::DeleteNetworkReachableAnalysisRequest& request) const;
GetInternetTupleOutcome getInternetTuple(const Model::GetInternetTupleRequest &request)const;
void getInternetTupleAsync(const Model::GetInternetTupleRequest& request, const GetInternetTupleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetInternetTupleOutcomeCallable getInternetTupleCallable(const Model::GetInternetTupleRequest& request) const;
GetNatTopNOutcome getNatTopN(const Model::GetNatTopNRequest &request)const;
void getNatTopNAsync(const Model::GetNatTopNRequest& request, const GetNatTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetNatTopNOutcomeCallable getNatTopNCallable(const Model::GetNatTopNRequest& request) const;
GetNetworkReachableAnalysisOutcome getNetworkReachableAnalysis(const Model::GetNetworkReachableAnalysisRequest &request)const;
void getNetworkReachableAnalysisAsync(const Model::GetNetworkReachableAnalysisRequest& request, const GetNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetNetworkReachableAnalysisOutcomeCallable getNetworkReachableAnalysisCallable(const Model::GetNetworkReachableAnalysisRequest& request) const;
GetNisNetworkMetricsOutcome getNisNetworkMetrics(const Model::GetNisNetworkMetricsRequest &request)const;
void getNisNetworkMetricsAsync(const Model::GetNisNetworkMetricsRequest& request, const GetNisNetworkMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetNisNetworkMetricsOutcomeCallable getNisNetworkMetricsCallable(const Model::GetNisNetworkMetricsRequest& request) const;
GetNisNetworkRankingOutcome getNisNetworkRanking(const Model::GetNisNetworkRankingRequest &request)const;
void getNisNetworkRankingAsync(const Model::GetNisNetworkRankingRequest& request, const GetNisNetworkRankingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetNisNetworkRankingOutcomeCallable getNisNetworkRankingCallable(const Model::GetNisNetworkRankingRequest& request) const;
GetTransitRouterFlowTopNOutcome getTransitRouterFlowTopN(const Model::GetTransitRouterFlowTopNRequest &request)const;
void getTransitRouterFlowTopNAsync(const Model::GetTransitRouterFlowTopNRequest& request, const GetTransitRouterFlowTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTransitRouterFlowTopNOutcomeCallable getTransitRouterFlowTopNCallable(const Model::GetTransitRouterFlowTopNRequest& request) const;
GetVbrFlowTopNOutcome getVbrFlowTopN(const Model::GetVbrFlowTopNRequest &request)const;
void getVbrFlowTopNAsync(const Model::GetVbrFlowTopNRequest& request, const GetVbrFlowTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVbrFlowTopNOutcomeCallable getVbrFlowTopNCallable(const Model::GetVbrFlowTopNRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_NIS_NISCLIENT_H_

32
nis/include/alibabacloud/nis/NisExport.h Normal file
View File

@@ -0,0 +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_NIS_NISEXPORT_H_
#define ALIBABACLOUD_NIS_NISEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_NIS_LIBRARY)
# define ALIBABACLOUD_NIS_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_NIS_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_NIS_EXPORT
#endif
#endif // !ALIBABACLOUD_NIS_NISEXPORT_H_

81
nis/include/alibabacloud/nis/model/CreateAndAnalyzeNetworkPathRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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_NIS_MODEL_CREATEANDANALYZENETWORKPATHREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT CreateAndAnalyzeNetworkPathRequest : public RpcServiceRequest {
public:
CreateAndAnalyzeNetworkPathRequest();
~CreateAndAnalyzeNetworkPathRequest();
std::string getTargetId() const;
void setTargetId(const std::string &targetId);
std::string getTargetType() const;
void setTargetType(const std::string &targetType);
std::string getTargetIpAddress() const;
void setTargetIpAddress(const std::string &targetIpAddress);
int getSourcePort() const;
void setSourcePort(int sourcePort);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
long getSourceAliUid() const;
void setSourceAliUid(long sourceAliUid);
std::string getSourceType() const;
void setSourceType(const std::string &sourceType);
std::string getAuditParam() const;
void setAuditParam(const std::string &auditParam);
int getTargetPort() const;
void setTargetPort(int targetPort);
std::string getSourceId() const;
void setSourceId(const std::string &sourceId);
std::string getSourceIpAddress() const;
void setSourceIpAddress(const std::string &sourceIpAddress);
bool getUseMultiAccount() const;
void setUseMultiAccount(bool useMultiAccount);
long getTargetAliUid() const;
void setTargetAliUid(long targetAliUid);
private:
std::string targetId_;
std::string targetType_;
std::string targetIpAddress_;
int sourcePort_;
std::string protocol_;
std::string regionId_;
long sourceAliUid_;
std::string sourceType_;
std::string auditParam_;
int targetPort_;
std::string sourceId_;
std::string sourceIpAddress_;
bool useMultiAccount_;
long targetAliUid_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHREQUEST_H_

69
nis/include/alibabacloud/nis/model/CreateAndAnalyzeNetworkPathResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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_NIS_MODEL_CREATEANDANALYZENETWORKPATHRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT CreateAndAnalyzeNetworkPathResult : public ServiceResult
{
public:
CreateAndAnalyzeNetworkPathResult();
explicit CreateAndAnalyzeNetworkPathResult(const std::string &payload);
~CreateAndAnalyzeNetworkPathResult();
std::string getTargetPort()const;
std::string getNetworkReachableAnalysisId()const;
std::string getSourceId()const;
std::string getSourceType()const;
std::string getTargetType()const;
std::string getSourcePort()const;
std::string getProtocol()const;
std::string getTargetId()const;
std::string getSourceIpAddress()const;
std::string getTargetIpAddress()const;
protected:
void parse(const std::string &payload);
private:
std::string targetPort_;
std::string networkReachableAnalysisId_;
std::string sourceId_;
std::string sourceType_;
std::string targetType_;
std::string sourcePort_;
std::string protocol_;
std::string targetId_;
std::string sourceIpAddress_;
std::string targetIpAddress_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHRESULT_H_

111
nis/include/alibabacloud/nis/model/CreateNetworkPathRequest.h Normal file
View File

@@ -0,0 +1,111 @@
/*
* 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_NIS_MODEL_CREATENETWORKPATHREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_CREATENETWORKPATHREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT CreateNetworkPathRequest : public RpcServiceRequest {
public:
struct SystemTag {
std::string key;
std::string value;
std::string scope;
};
struct Tag {
std::string key;
std::string value;
};
CreateNetworkPathRequest();
~CreateNetworkPathRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getTargetId() const;
void setTargetId(const std::string &targetId);
std::string getTargetType() const;
void setTargetType(const std::string &targetType);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::vector<SystemTag> getSystemTag() const;
void setSystemTag(const std::vector<SystemTag> &systemTag);
std::string getTargetIpAddress() const;
void setTargetIpAddress(const std::string &targetIpAddress);
std::string getNetworkPathName() const;
void setNetworkPathName(const std::string &networkPathName);
int getSourcePort() const;
void setSourcePort(int sourcePort);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
long getSourceAliUid() const;
void setSourceAliUid(long sourceAliUid);
std::string getSourceType() const;
void setSourceType(const std::string &sourceType);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
int getTargetPort() const;
void setTargetPort(int targetPort);
std::string getSourceId() const;
void setSourceId(const std::string &sourceId);
std::string getSourceIpAddress() const;
void setSourceIpAddress(const std::string &sourceIpAddress);
bool getDryRun() const;
void setDryRun(bool dryRun);
bool getUseMultiAccount() const;
void setUseMultiAccount(bool useMultiAccount);
std::string getNetworkPathDescription() const;
void setNetworkPathDescription(const std::string &networkPathDescription);
long getTargetAliUid() const;
void setTargetAliUid(long targetAliUid);
private:
long resourceOwnerId_;
std::string targetId_;
std::string targetType_;
std::string clientToken_;
std::vector<SystemTag> systemTag_;
std::string targetIpAddress_;
std::string networkPathName_;
int sourcePort_;
std::string resourceGroupId_;
std::string protocol_;
std::string regionId_;
long sourceAliUid_;
std::string sourceType_;
std::vector<Tag> tag_;
int targetPort_;
std::string sourceId_;
std::string sourceIpAddress_;
bool dryRun_;
bool useMultiAccount_;
std::string networkPathDescription_;
long targetAliUid_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_CREATENETWORKPATHREQUEST_H_

51
nis/include/alibabacloud/nis/model/CreateNetworkPathResult.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_NIS_MODEL_CREATENETWORKPATHRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_CREATENETWORKPATHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT CreateNetworkPathResult : public ServiceResult
{
public:
CreateNetworkPathResult();
explicit CreateNetworkPathResult(const std::string &payload);
~CreateNetworkPathResult();
std::string getNetworkPathId()const;
protected:
void parse(const std::string &payload);
private:
std::string networkPathId_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_CREATENETWORKPATHRESULT_H_

72
nis/include/alibabacloud/nis/model/CreateNetworkReachableAnalysisRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* 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_NIS_MODEL_CREATENETWORKREACHABLEANALYSISREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_CREATENETWORKREACHABLEANALYSISREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT CreateNetworkReachableAnalysisRequest : public RpcServiceRequest {
public:
struct SystemTag {
std::string key;
std::string value;
std::string scope;
};
struct Tag {
std::string key;
std::string value;
};
CreateNetworkReachableAnalysisRequest();
~CreateNetworkReachableAnalysisRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
bool getDryRun() const;
void setDryRun(bool dryRun);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::vector<SystemTag> getSystemTag() const;
void setSystemTag(const std::vector<SystemTag> &systemTag);
std::string getNetworkPathId() const;
void setNetworkPathId(const std::string &networkPathId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getAuditParam() const;
void setAuditParam(const std::string &auditParam);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
private:
long resourceOwnerId_;
bool dryRun_;
std::string clientToken_;
std::vector<SystemTag> systemTag_;
std::string networkPathId_;
std::string regionId_;
std::string auditParam_;
std::vector<Tag> tag_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_CREATENETWORKREACHABLEANALYSISREQUEST_H_

51
nis/include/alibabacloud/nis/model/CreateNetworkReachableAnalysisResult.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_NIS_MODEL_CREATENETWORKREACHABLEANALYSISRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_CREATENETWORKREACHABLEANALYSISRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT CreateNetworkReachableAnalysisResult : public ServiceResult
{
public:
CreateNetworkReachableAnalysisResult();
explicit CreateNetworkReachableAnalysisResult(const std::string &payload);
~CreateNetworkReachableAnalysisResult();
std::string getNetworkReachableAnalysisId()const;
protected:
void parse(const std::string &payload);
private:
std::string networkReachableAnalysisId_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_CREATENETWORKREACHABLEANALYSISRESULT_H_

51
nis/include/alibabacloud/nis/model/DeleteNetworkPathRequest.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_NIS_MODEL_DELETENETWORKPATHREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_DELETENETWORKPATHREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT DeleteNetworkPathRequest : public RpcServiceRequest {
public:
DeleteNetworkPathRequest();
~DeleteNetworkPathRequest();
bool getDryRun() const;
void setDryRun(bool dryRun);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::vector<std::string> getNetworkPathIds() const;
void setNetworkPathIds(const std::vector<std::string> &networkPathIds);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
bool dryRun_;
std::string clientToken_;
std::vector<std::string> networkPathIds_;
std::string regionId_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_DELETENETWORKPATHREQUEST_H_

51
nis/include/alibabacloud/nis/model/DeleteNetworkPathResult.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_NIS_MODEL_DELETENETWORKPATHRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_DELETENETWORKPATHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT DeleteNetworkPathResult : public ServiceResult
{
public:
DeleteNetworkPathResult();
explicit DeleteNetworkPathResult(const std::string &payload);
~DeleteNetworkPathResult();
bool getData()const;
protected:
void parse(const std::string &payload);
private:
bool data_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_DELETENETWORKPATHRESULT_H_

51
nis/include/alibabacloud/nis/model/DeleteNetworkReachableAnalysisRequest.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_NIS_MODEL_DELETENETWORKREACHABLEANALYSISREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_DELETENETWORKREACHABLEANALYSISREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT DeleteNetworkReachableAnalysisRequest : public RpcServiceRequest {
public:
DeleteNetworkReachableAnalysisRequest();
~DeleteNetworkReachableAnalysisRequest();
bool getDryRun() const;
void setDryRun(bool dryRun);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<std::string> getNetworkReachableAnalysisIds() const;
void setNetworkReachableAnalysisIds(const std::vector<std::string> &networkReachableAnalysisIds);
private:
bool dryRun_;
std::string clientToken_;
std::string regionId_;
std::vector<std::string> networkReachableAnalysisIds_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_DELETENETWORKREACHABLEANALYSISREQUEST_H_

51
nis/include/alibabacloud/nis/model/DeleteNetworkReachableAnalysisResult.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_NIS_MODEL_DELETENETWORKREACHABLEANALYSISRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_DELETENETWORKREACHABLEANALYSISRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT DeleteNetworkReachableAnalysisResult : public ServiceResult
{
public:
DeleteNetworkReachableAnalysisResult();
explicit DeleteNetworkReachableAnalysisResult(const std::string &payload);
~DeleteNetworkReachableAnalysisResult();
bool getData()const;
protected:
void parse(const std::string &payload);
private:
bool data_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_DELETENETWORKREACHABLEANALYSISRESULT_H_

105
nis/include/alibabacloud/nis/model/GetInternetTupleRequest.h Normal file
View File

@@ -0,0 +1,105 @@
/*
* 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_NIS_MODEL_GETINTERNETTUPLEREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLEREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT GetInternetTupleRequest : public RpcServiceRequest {
public:
GetInternetTupleRequest();
~GetInternetTupleRequest();
std::string getOtherPort() const;
void setOtherPort(const std::string &otherPort);
std::string getCloudIsp() const;
void setCloudIsp(const std::string &cloudIsp);
int getTopN() const;
void setTopN(int topN);
std::string getCloudPort() const;
void setCloudPort(const std::string &cloudPort);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getOtherIp() const;
void setOtherIp(const std::string &otherIp);
std::vector<std::string> getInstanceList() const;
void setInstanceList(const std::vector<std::string> &instanceList);
std::string getOrderBy() const;
void setOrderBy(const std::string &orderBy);
std::string getSort() const;
void setSort(const std::string &sort);
bool getUseMultiAccount() const;
void setUseMultiAccount(bool useMultiAccount);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
int getTupleType() const;
void setTupleType(int tupleType);
std::string getCloudIp() const;
void setCloudIp(const std::string &cloudIp);
std::vector<std::string> getCloudIpList() const;
void setCloudIpList(const std::vector<std::string> &cloudIpList);
std::string getOtherIsp() const;
void setOtherIsp(const std::string &otherIsp);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getOtherCountry() const;
void setOtherCountry(const std::string &otherCountry);
std::string getDirection() const;
void setDirection(const std::string &direction);
long getEndTime() const;
void setEndTime(long endTime);
long getBeginTime() const;
void setBeginTime(long beginTime);
std::string getOtherCity() const;
void setOtherCity(const std::string &otherCity);
std::vector<long> getAccountIds() const;
void setAccountIds(const std::vector<long> &accountIds);
private:
std::string otherPort_;
std::string cloudIsp_;
int topN_;
std::string cloudPort_;
std::string protocol_;
std::string otherIp_;
std::vector<std::string> instanceList_;
std::string orderBy_;
std::string sort_;
bool useMultiAccount_;
std::string instanceId_;
int tupleType_;
std::string cloudIp_;
std::vector<std::string> cloudIpList_;
std::string otherIsp_;
std::string regionId_;
std::string otherCountry_;
std::string direction_;
long endTime_;
long beginTime_;
std::string otherCity_;
std::vector<long> accountIds_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLEREQUEST_H_

87
nis/include/alibabacloud/nis/model/GetInternetTupleResult.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* 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_NIS_MODEL_GETINTERNETTUPLERESULT_H_
#define ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT GetInternetTupleResult : public ServiceResult
{
public:
struct DataItem
{
std::string cloudIp;
double inRetranCount;
double outPacketCount;
std::string otherProvince;
std::string beginTime;
std::string otherProduct;
double packetCount;
double inByteCount;
std::string direction;
std::string cloudProduct;
std::string otherIp;
double rtt;
std::string cloudProvince;
std::string otherCity;
std::string otherCountry;
double outByteCount;
std::string protocol;
std::string cloudCountry;
double inPacketCount;
std::string cloudCity;
double byteCount;
std::string instanceId;
std::string otherPort;
double outOutOrderCount;
double retranCount;
double outRetranCount;
std::string cloudIsp;
std::string accessRegion;
double retransmitRate;
double inOutOrderCount;
double outOrderCount;
std::string otherIsp;
std::string cloudPort;
};
GetInternetTupleResult();
explicit GetInternetTupleResult(const std::string &payload);
~GetInternetTupleResult();
std::vector<DataItem> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DataItem> data_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLERESULT_H_

60
nis/include/alibabacloud/nis/model/GetNatTopNRequest.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_NIS_MODEL_GETNATTOPNREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_GETNATTOPNREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT GetNatTopNRequest : public RpcServiceRequest {
public:
GetNatTopNRequest();
~GetNatTopNRequest();
std::string getIp() const;
void setIp(const std::string &ip);
long getEndTime() const;
void setEndTime(long endTime);
std::string getOrderBy() const;
void setOrderBy(const std::string &orderBy);
long getBeginTime() const;
void setBeginTime(long beginTime);
int getTopN() const;
void setTopN(int topN);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNatGatewayId() const;
void setNatGatewayId(const std::string &natGatewayId);
private:
std::string ip_;
long endTime_;
std::string orderBy_;
long beginTime_;
int topN_;
std::string regionId_;
std::string natGatewayId_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_GETNATTOPNREQUEST_H_

65
nis/include/alibabacloud/nis/model/GetNatTopNResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_NIS_MODEL_GETNATTOPNRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_GETNATTOPNRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT GetNatTopNResult : public ServiceResult
{
public:
struct NatGatewayTopNItem
{
float outPps;
float outBps;
std::string ip;
float inBps;
float newSessionPerSecond;
float outFlowPerMinute;
float inPps;
float activeSessionCount;
float inFlowPerMinute;
};
GetNatTopNResult();
explicit GetNatTopNResult(const std::string &payload);
~GetNatTopNResult();
std::vector<NatGatewayTopNItem> getNatGatewayTopN()const;
bool getIsTopNOpen()const;
protected:
void parse(const std::string &payload);
private:
std::vector<NatGatewayTopNItem> natGatewayTopN_;
bool isTopNOpen_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_GETNATTOPNRESULT_H_

45
nis/include/alibabacloud/nis/model/GetNetworkReachableAnalysisRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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_NIS_MODEL_GETNETWORKREACHABLEANALYSISREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_GETNETWORKREACHABLEANALYSISREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT GetNetworkReachableAnalysisRequest : public RpcServiceRequest {
public:
GetNetworkReachableAnalysisRequest();
~GetNetworkReachableAnalysisRequest();
std::string getNetworkReachableAnalysisId() const;
void setNetworkReachableAnalysisId(const std::string &networkReachableAnalysisId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string networkReachableAnalysisId_;
std::string regionId_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_GETNETWORKREACHABLEANALYSISREQUEST_H_

65
nis/include/alibabacloud/nis/model/GetNetworkReachableAnalysisResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_NIS_MODEL_GETNETWORKREACHABLEANALYSISRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_GETNETWORKREACHABLEANALYSISRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT GetNetworkReachableAnalysisResult : public ServiceResult
{
public:
GetNetworkReachableAnalysisResult();
explicit GetNetworkReachableAnalysisResult(const std::string &payload);
~GetNetworkReachableAnalysisResult();
std::string getNetworkReachableAnalysisId()const;
std::string getCreateTime()const;
bool getReachable()const;
std::string getNetworkPathId()const;
std::string getNetworkReachableAnalysisResult()const;
std::string getNetworkReachableAnalysisStatus()const;
long getAliUid()const;
std::string getNetworkPathParameter()const;
protected:
void parse(const std::string &payload);
private:
std::string networkReachableAnalysisId_;
std::string createTime_;
bool reachable_;
std::string networkPathId_;
std::string networkReachableAnalysisResult_;
std::string networkReachableAnalysisStatus_;
long aliUid_;
std::string networkPathParameter_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_GETNETWORKREACHABLEANALYSISRESULT_H_

70
nis/include/alibabacloud/nis/model/GetNisNetworkMetricsRequest.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* 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_NIS_MODEL_GETNISNETWORKMETRICSREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_GETNISNETWORKMETRICSREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT GetNisNetworkMetricsRequest : public RpcServiceRequest {
public:
struct Dimensions {
std::string name;
std::string value;
};
GetNisNetworkMetricsRequest();
~GetNisNetworkMetricsRequest();
bool getUseCrossAccount() const;
void setUseCrossAccount(bool useCrossAccount);
std::string getScanBy() const;
void setScanBy(const std::string &scanBy);
std::string getMetricName() const;
void setMetricName(const std::string &metricName);
long getEndTime() const;
void setEndTime(long endTime);
long getBeginTime() const;
void setBeginTime(long beginTime);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getRegionNo() const;
void setRegionNo(const std::string &regionNo);
std::vector<std::string> getAccountIds() const;
void setAccountIds(const std::vector<std::string> &accountIds);
std::vector<Dimensions> getDimensions() const;
void setDimensions(const std::vector<Dimensions> &dimensions);
private:
bool useCrossAccount_;
std::string scanBy_;
std::string metricName_;
long endTime_;
long beginTime_;
std::string resourceType_;
std::string regionNo_;
std::vector<std::string> accountIds_;
std::vector<Dimensions> dimensions_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_GETNISNETWORKMETRICSREQUEST_H_

61
nis/include/alibabacloud/nis/model/GetNisNetworkMetricsResult.h Normal file
View File

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

79
nis/include/alibabacloud/nis/model/GetNisNetworkRankingRequest.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* 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_NIS_MODEL_GETNISNETWORKRANKINGREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT GetNisNetworkRankingRequest : public RpcServiceRequest {
public:
struct Filter {
std::string name;
std::string value;
};
GetNisNetworkRankingRequest();
~GetNisNetworkRankingRequest();
bool getUseCrossAccount() const;
void setUseCrossAccount(bool useCrossAccount);
int getTopN() const;
void setTopN(int topN);
std::string getDirection() const;
void setDirection(const std::string &direction);
std::string getOrderBy() const;
void setOrderBy(const std::string &orderBy);
long getEndTime() const;
void setEndTime(long endTime);
long getBeginTime() const;
void setBeginTime(long beginTime);
std::string getGroupBy() const;
void setGroupBy(const std::string &groupBy);
std::string getSort() const;
void setSort(const std::string &sort);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getRegionNo() const;
void setRegionNo(const std::string &regionNo);
std::vector<Filter> getFilter() const;
void setFilter(const std::vector<Filter> &filter);
std::vector<std::string> getAccountIds() const;
void setAccountIds(const std::vector<std::string> &accountIds);
private:
bool useCrossAccount_;
int topN_;
std::string direction_;
std::string orderBy_;
long endTime_;
long beginTime_;
std::string groupBy_;
std::string sort_;
std::string resourceType_;
std::string regionNo_;
std::vector<Filter> filter_;
std::vector<std::string> accountIds_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGREQUEST_H_

85
nis/include/alibabacloud/nis/model/GetNisNetworkRankingResult.h Normal file
View File

@@ -0,0 +1,85 @@
/*
* 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_NIS_MODEL_GETNISNETWORKRANKINGRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT GetNisNetworkRankingResult : public ServiceResult
{
public:
struct Rankings
{
std::string regionNo;
std::string destinationIsp;
double activeSessionCount;
std::string destinationRegionNo;
std::string vbrId;
double packetCount;
std::string sourcePort;
std::string destinationPort;
double outPps;
std::string destinationIp;
std::string sourceZone;
double rTT;
double inBps;
std::string bandwidthPackageId;
double inPps;
std::string protocol;
std::string asn;
double outBps;
double byteCount;
std::string instanceId;
std::string isp;
std::string iP;
double newSessionPerSecond;
std::string city;
std::string province;
std::string attachmentId;
double retransmitRate;
std::string sourceIp;
std::string country;
std::string destinationZone;
std::string sourceIsp;
};
GetNisNetworkRankingResult();
explicit GetNisNetworkRankingResult(const std::string &payload);
~GetNisNetworkRankingResult();
std::vector<Rankings> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Rankings> data_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGRESULT_H_

93
nis/include/alibabacloud/nis/model/GetTransitRouterFlowTopNRequest.h 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.
*/
#ifndef ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT GetTransitRouterFlowTopNRequest : public RpcServiceRequest {
public:
GetTransitRouterFlowTopNRequest();
~GetTransitRouterFlowTopNRequest();
std::string getOtherPort() const;
void setOtherPort(const std::string &otherPort);
int getTopN() const;
void setTopN(int topN);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getThisIp() const;
void setThisIp(const std::string &thisIp);
std::string getOtherIp() const;
void setOtherIp(const std::string &otherIp);
std::string getBandwithPackageId() const;
void setBandwithPackageId(const std::string &bandwithPackageId);
std::string getOrderBy() const;
void setOrderBy(const std::string &orderBy);
std::string getSort() const;
void setSort(const std::string &sort);
bool getUseMultiAccount() const;
void setUseMultiAccount(bool useMultiAccount);
std::string getThisRegion() const;
void setThisRegion(const std::string &thisRegion);
std::string getCenId() const;
void setCenId(const std::string &cenId);
std::string getThisPort() const;
void setThisPort(const std::string &thisPort);
std::string getDirection() const;
void setDirection(const std::string &direction);
std::string getOtherRegion() const;
void setOtherRegion(const std::string &otherRegion);
long getEndTime() const;
void setEndTime(long endTime);
long getBeginTime() const;
void setBeginTime(long beginTime);
std::string getGroupBy() const;
void setGroupBy(const std::string &groupBy);
std::vector<long> getAccountIds() const;
void setAccountIds(const std::vector<long> &accountIds);
private:
std::string otherPort_;
int topN_;
std::string protocol_;
std::string thisIp_;
std::string otherIp_;
std::string bandwithPackageId_;
std::string orderBy_;
std::string sort_;
bool useMultiAccount_;
std::string thisRegion_;
std::string cenId_;
std::string thisPort_;
std::string direction_;
std::string otherRegion_;
long endTime_;
long beginTime_;
std::string groupBy_;
std::vector<long> accountIds_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNREQUEST_H_

68
nis/include/alibabacloud/nis/model/GetTransitRouterFlowTopNResult.h 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.
*/
#ifndef ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT GetTransitRouterFlowTopNResult : public ServiceResult
{
public:
struct TrFlowlogTopN
{
std::string accountId;
std::string endTime;
std::string otherPort;
std::string thisIp;
std::string startTime;
std::string thisRegion;
std::string thisPort;
std::string otherIp;
double bytes;
std::string otherRegion;
double packets;
std::string bandwithPackageId;
std::string cenId;
std::string protocol;
};
GetTransitRouterFlowTopNResult();
explicit GetTransitRouterFlowTopNResult(const std::string &payload);
~GetTransitRouterFlowTopNResult();
std::vector<TrFlowlogTopN> getTransitRouterFlowTopN()const;
protected:
void parse(const std::string &payload);
private:
std::vector<TrFlowlogTopN> transitRouterFlowTopN_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNRESULT_H_

93
nis/include/alibabacloud/nis/model/GetVbrFlowTopNRequest.h 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.
*/
#ifndef ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNREQUEST_H_
#define ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNREQUEST_H_
#include <alibabacloud/nis/NisExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Nis {
namespace Model {
class ALIBABACLOUD_NIS_EXPORT GetVbrFlowTopNRequest : public RpcServiceRequest {
public:
GetVbrFlowTopNRequest();
~GetVbrFlowTopNRequest();
std::string getOtherPort() const;
void setOtherPort(const std::string &otherPort);
int getTopN() const;
void setTopN(int topN);
std::string getCloudPort() const;
void setCloudPort(const std::string &cloudPort);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getOtherIp() const;
void setOtherIp(const std::string &otherIp);
std::string getOrderBy() const;
void setOrderBy(const std::string &orderBy);
std::string getSort() const;
void setSort(const std::string &sort);
bool getUseMultiAccount() const;
void setUseMultiAccount(bool useMultiAccount);
std::string getCloudIp() const;
void setCloudIp(const std::string &cloudIp);
std::string getCenId() const;
void setCenId(const std::string &cenId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVirtualBorderRouterId() const;
void setVirtualBorderRouterId(const std::string &virtualBorderRouterId);
std::string getDirection() const;
void setDirection(const std::string &direction);
long getEndTime() const;
void setEndTime(long endTime);
long getBeginTime() const;
void setBeginTime(long beginTime);
std::string getGroupBy() const;
void setGroupBy(const std::string &groupBy);
std::vector<long> getAccountIds() const;
void setAccountIds(const std::vector<long> &accountIds);
std::string getAttachmentId() const;
void setAttachmentId(const std::string &attachmentId);
private:
std::string otherPort_;
int topN_;
std::string cloudPort_;
std::string protocol_;
std::string otherIp_;
std::string orderBy_;
std::string sort_;
bool useMultiAccount_;
std::string cloudIp_;
std::string cenId_;
std::string regionId_;
std::string virtualBorderRouterId_;
std::string direction_;
long endTime_;
long beginTime_;
std::string groupBy_;
std::vector<long> accountIds_;
std::string attachmentId_;
};
} // namespace Model
} // namespace Nis
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNREQUEST_H_

65
nis/include/alibabacloud/nis/model/GetVbrFlowTopNResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_NIS_MODEL_GETVBRFLOWTOPNRESULT_H_
#define ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/nis/NisExport.h>
namespace AlibabaCloud
{
namespace Nis
{
namespace Model
{
class ALIBABACLOUD_NIS_EXPORT GetVbrFlowTopNResult : public ServiceResult
{
public:
struct VbrFlowlogTopN
{
std::string otherIp;
std::string cloudRegion;
double bytes;
std::string cloudIp;
std::string accountId;
std::string otherPort;
double packets;
std::string protocol;
std::string attachmentId;
std::string virtualBorderRouterId;
std::string cloudPort;
};
GetVbrFlowTopNResult();
explicit GetVbrFlowTopNResult(const std::string &payload);
~GetVbrFlowTopNResult();
std::vector<VbrFlowlogTopN> getVirtualBorderRouterFlowlogTopN()const;
protected:
void parse(const std::string &payload);
private:
std::vector<VbrFlowlogTopN> virtualBorderRouterFlowlogTopN_;
};
}
}
}
#endif // !ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNRESULT_H_

485
nis/src/NisClient.cc Normal file
View File

@@ -0,0 +1,485 @@
/*
* 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/nis/NisClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
namespace
{
const std::string SERVICE_NAME = "nis";
}
NisClient::NisClient(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, "networkana");
}
NisClient::NisClient(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, "networkana");
}
NisClient::NisClient(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, "networkana");
}
NisClient::~NisClient()
{}
NisClient::CreateAndAnalyzeNetworkPathOutcome NisClient::createAndAnalyzeNetworkPath(const CreateAndAnalyzeNetworkPathRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateAndAnalyzeNetworkPathOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateAndAnalyzeNetworkPathOutcome(CreateAndAnalyzeNetworkPathResult(outcome.result()));
else
return CreateAndAnalyzeNetworkPathOutcome(outcome.error());
}
void NisClient::createAndAnalyzeNetworkPathAsync(const CreateAndAnalyzeNetworkPathRequest& request, const CreateAndAnalyzeNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createAndAnalyzeNetworkPath(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::CreateAndAnalyzeNetworkPathOutcomeCallable NisClient::createAndAnalyzeNetworkPathCallable(const CreateAndAnalyzeNetworkPathRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateAndAnalyzeNetworkPathOutcome()>>(
[this, request]()
{
return this->createAndAnalyzeNetworkPath(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::CreateNetworkPathOutcome NisClient::createNetworkPath(const CreateNetworkPathRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateNetworkPathOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateNetworkPathOutcome(CreateNetworkPathResult(outcome.result()));
else
return CreateNetworkPathOutcome(outcome.error());
}
void NisClient::createNetworkPathAsync(const CreateNetworkPathRequest& request, const CreateNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createNetworkPath(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::CreateNetworkPathOutcomeCallable NisClient::createNetworkPathCallable(const CreateNetworkPathRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateNetworkPathOutcome()>>(
[this, request]()
{
return this->createNetworkPath(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::CreateNetworkReachableAnalysisOutcome NisClient::createNetworkReachableAnalysis(const CreateNetworkReachableAnalysisRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateNetworkReachableAnalysisOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateNetworkReachableAnalysisOutcome(CreateNetworkReachableAnalysisResult(outcome.result()));
else
return CreateNetworkReachableAnalysisOutcome(outcome.error());
}
void NisClient::createNetworkReachableAnalysisAsync(const CreateNetworkReachableAnalysisRequest& request, const CreateNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createNetworkReachableAnalysis(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::CreateNetworkReachableAnalysisOutcomeCallable NisClient::createNetworkReachableAnalysisCallable(const CreateNetworkReachableAnalysisRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateNetworkReachableAnalysisOutcome()>>(
[this, request]()
{
return this->createNetworkReachableAnalysis(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::DeleteNetworkPathOutcome NisClient::deleteNetworkPath(const DeleteNetworkPathRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteNetworkPathOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteNetworkPathOutcome(DeleteNetworkPathResult(outcome.result()));
else
return DeleteNetworkPathOutcome(outcome.error());
}
void NisClient::deleteNetworkPathAsync(const DeleteNetworkPathRequest& request, const DeleteNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteNetworkPath(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::DeleteNetworkPathOutcomeCallable NisClient::deleteNetworkPathCallable(const DeleteNetworkPathRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteNetworkPathOutcome()>>(
[this, request]()
{
return this->deleteNetworkPath(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::DeleteNetworkReachableAnalysisOutcome NisClient::deleteNetworkReachableAnalysis(const DeleteNetworkReachableAnalysisRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteNetworkReachableAnalysisOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteNetworkReachableAnalysisOutcome(DeleteNetworkReachableAnalysisResult(outcome.result()));
else
return DeleteNetworkReachableAnalysisOutcome(outcome.error());
}
void NisClient::deleteNetworkReachableAnalysisAsync(const DeleteNetworkReachableAnalysisRequest& request, const DeleteNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteNetworkReachableAnalysis(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::DeleteNetworkReachableAnalysisOutcomeCallable NisClient::deleteNetworkReachableAnalysisCallable(const DeleteNetworkReachableAnalysisRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteNetworkReachableAnalysisOutcome()>>(
[this, request]()
{
return this->deleteNetworkReachableAnalysis(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::GetInternetTupleOutcome NisClient::getInternetTuple(const GetInternetTupleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetInternetTupleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetInternetTupleOutcome(GetInternetTupleResult(outcome.result()));
else
return GetInternetTupleOutcome(outcome.error());
}
void NisClient::getInternetTupleAsync(const GetInternetTupleRequest& request, const GetInternetTupleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getInternetTuple(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::GetInternetTupleOutcomeCallable NisClient::getInternetTupleCallable(const GetInternetTupleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetInternetTupleOutcome()>>(
[this, request]()
{
return this->getInternetTuple(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::GetNatTopNOutcome NisClient::getNatTopN(const GetNatTopNRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetNatTopNOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetNatTopNOutcome(GetNatTopNResult(outcome.result()));
else
return GetNatTopNOutcome(outcome.error());
}
void NisClient::getNatTopNAsync(const GetNatTopNRequest& request, const GetNatTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getNatTopN(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::GetNatTopNOutcomeCallable NisClient::getNatTopNCallable(const GetNatTopNRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetNatTopNOutcome()>>(
[this, request]()
{
return this->getNatTopN(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::GetNetworkReachableAnalysisOutcome NisClient::getNetworkReachableAnalysis(const GetNetworkReachableAnalysisRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetNetworkReachableAnalysisOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetNetworkReachableAnalysisOutcome(GetNetworkReachableAnalysisResult(outcome.result()));
else
return GetNetworkReachableAnalysisOutcome(outcome.error());
}
void NisClient::getNetworkReachableAnalysisAsync(const GetNetworkReachableAnalysisRequest& request, const GetNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getNetworkReachableAnalysis(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::GetNetworkReachableAnalysisOutcomeCallable NisClient::getNetworkReachableAnalysisCallable(const GetNetworkReachableAnalysisRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetNetworkReachableAnalysisOutcome()>>(
[this, request]()
{
return this->getNetworkReachableAnalysis(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::GetNisNetworkMetricsOutcome NisClient::getNisNetworkMetrics(const GetNisNetworkMetricsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetNisNetworkMetricsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetNisNetworkMetricsOutcome(GetNisNetworkMetricsResult(outcome.result()));
else
return GetNisNetworkMetricsOutcome(outcome.error());
}
void NisClient::getNisNetworkMetricsAsync(const GetNisNetworkMetricsRequest& request, const GetNisNetworkMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getNisNetworkMetrics(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::GetNisNetworkMetricsOutcomeCallable NisClient::getNisNetworkMetricsCallable(const GetNisNetworkMetricsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetNisNetworkMetricsOutcome()>>(
[this, request]()
{
return this->getNisNetworkMetrics(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::GetNisNetworkRankingOutcome NisClient::getNisNetworkRanking(const GetNisNetworkRankingRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetNisNetworkRankingOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetNisNetworkRankingOutcome(GetNisNetworkRankingResult(outcome.result()));
else
return GetNisNetworkRankingOutcome(outcome.error());
}
void NisClient::getNisNetworkRankingAsync(const GetNisNetworkRankingRequest& request, const GetNisNetworkRankingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getNisNetworkRanking(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::GetNisNetworkRankingOutcomeCallable NisClient::getNisNetworkRankingCallable(const GetNisNetworkRankingRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetNisNetworkRankingOutcome()>>(
[this, request]()
{
return this->getNisNetworkRanking(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::GetTransitRouterFlowTopNOutcome NisClient::getTransitRouterFlowTopN(const GetTransitRouterFlowTopNRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTransitRouterFlowTopNOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTransitRouterFlowTopNOutcome(GetTransitRouterFlowTopNResult(outcome.result()));
else
return GetTransitRouterFlowTopNOutcome(outcome.error());
}
void NisClient::getTransitRouterFlowTopNAsync(const GetTransitRouterFlowTopNRequest& request, const GetTransitRouterFlowTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTransitRouterFlowTopN(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::GetTransitRouterFlowTopNOutcomeCallable NisClient::getTransitRouterFlowTopNCallable(const GetTransitRouterFlowTopNRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTransitRouterFlowTopNOutcome()>>(
[this, request]()
{
return this->getTransitRouterFlowTopN(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
NisClient::GetVbrFlowTopNOutcome NisClient::getVbrFlowTopN(const GetVbrFlowTopNRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVbrFlowTopNOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVbrFlowTopNOutcome(GetVbrFlowTopNResult(outcome.result()));
else
return GetVbrFlowTopNOutcome(outcome.error());
}
void NisClient::getVbrFlowTopNAsync(const GetVbrFlowTopNRequest& request, const GetVbrFlowTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVbrFlowTopN(request), context);
};
asyncExecute(new Runnable(fn));
}
NisClient::GetVbrFlowTopNOutcomeCallable NisClient::getVbrFlowTopNCallable(const GetVbrFlowTopNRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVbrFlowTopNOutcome()>>(
[this, request]()
{
return this->getVbrFlowTopN(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

153
nis/src/model/CreateAndAnalyzeNetworkPathRequest.cc Normal file
View File

@@ -0,0 +1,153 @@
/*
* 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/nis/model/CreateAndAnalyzeNetworkPathRequest.h>
using AlibabaCloud::Nis::Model::CreateAndAnalyzeNetworkPathRequest;
CreateAndAnalyzeNetworkPathRequest::CreateAndAnalyzeNetworkPathRequest()
: RpcServiceRequest("nis", "2021-12-16", "CreateAndAnalyzeNetworkPath") {
setMethod(HttpRequest::Method::Get);
}
CreateAndAnalyzeNetworkPathRequest::~CreateAndAnalyzeNetworkPathRequest() {}
std::string CreateAndAnalyzeNetworkPathRequest::getTargetId() const {
return targetId_;
}
void CreateAndAnalyzeNetworkPathRequest::setTargetId(const std::string &targetId) {
targetId_ = targetId;
setParameter(std::string("TargetId"), targetId);
}
std::string CreateAndAnalyzeNetworkPathRequest::getTargetType() const {
return targetType_;
}
void CreateAndAnalyzeNetworkPathRequest::setTargetType(const std::string &targetType) {
targetType_ = targetType;
setParameter(std::string("TargetType"), targetType);
}
std::string CreateAndAnalyzeNetworkPathRequest::getTargetIpAddress() const {
return targetIpAddress_;
}
void CreateAndAnalyzeNetworkPathRequest::setTargetIpAddress(const std::string &targetIpAddress) {
targetIpAddress_ = targetIpAddress;
setParameter(std::string("TargetIpAddress"), targetIpAddress);
}
int CreateAndAnalyzeNetworkPathRequest::getSourcePort() const {
return sourcePort_;
}
void CreateAndAnalyzeNetworkPathRequest::setSourcePort(int sourcePort) {
sourcePort_ = sourcePort;
setParameter(std::string("SourcePort"), std::to_string(sourcePort));
}
std::string CreateAndAnalyzeNetworkPathRequest::getProtocol() const {
return protocol_;
}
void CreateAndAnalyzeNetworkPathRequest::setProtocol(const std::string &protocol) {
protocol_ = protocol;
setParameter(std::string("Protocol"), protocol);
}
std::string CreateAndAnalyzeNetworkPathRequest::getRegionId() const {
return regionId_;
}
void CreateAndAnalyzeNetworkPathRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
long CreateAndAnalyzeNetworkPathRequest::getSourceAliUid() const {
return sourceAliUid_;
}
void CreateAndAnalyzeNetworkPathRequest::setSourceAliUid(long sourceAliUid) {
sourceAliUid_ = sourceAliUid;
setParameter(std::string("SourceAliUid"), std::to_string(sourceAliUid));
}
std::string CreateAndAnalyzeNetworkPathRequest::getSourceType() const {
return sourceType_;
}
void CreateAndAnalyzeNetworkPathRequest::setSourceType(const std::string &sourceType) {
sourceType_ = sourceType;
setParameter(std::string("SourceType"), sourceType);
}
std::string CreateAndAnalyzeNetworkPathRequest::getAuditParam() const {
return auditParam_;
}
void CreateAndAnalyzeNetworkPathRequest::setAuditParam(const std::string &auditParam) {
auditParam_ = auditParam;
setParameter(std::string("AuditParam"), auditParam);
}
int CreateAndAnalyzeNetworkPathRequest::getTargetPort() const {
return targetPort_;
}
void CreateAndAnalyzeNetworkPathRequest::setTargetPort(int targetPort) {
targetPort_ = targetPort;
setParameter(std::string("TargetPort"), std::to_string(targetPort));
}
std::string CreateAndAnalyzeNetworkPathRequest::getSourceId() const {
return sourceId_;
}
void CreateAndAnalyzeNetworkPathRequest::setSourceId(const std::string &sourceId) {
sourceId_ = sourceId;
setParameter(std::string("SourceId"), sourceId);
}
std::string CreateAndAnalyzeNetworkPathRequest::getSourceIpAddress() const {
return sourceIpAddress_;
}
void CreateAndAnalyzeNetworkPathRequest::setSourceIpAddress(const std::string &sourceIpAddress) {
sourceIpAddress_ = sourceIpAddress;
setParameter(std::string("SourceIpAddress"), sourceIpAddress);
}
bool CreateAndAnalyzeNetworkPathRequest::getUseMultiAccount() const {
return useMultiAccount_;
}
void CreateAndAnalyzeNetworkPathRequest::setUseMultiAccount(bool useMultiAccount) {
useMultiAccount_ = useMultiAccount;
setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
}
long CreateAndAnalyzeNetworkPathRequest::getTargetAliUid() const {
return targetAliUid_;
}
void CreateAndAnalyzeNetworkPathRequest::setTargetAliUid(long targetAliUid) {
targetAliUid_ = targetAliUid;
setParameter(std::string("TargetAliUid"), std::to_string(targetAliUid));
}

114
nis/src/model/CreateAndAnalyzeNetworkPathResult.cc Normal file
View File

@@ -0,0 +1,114 @@
/*
* 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/nis/model/CreateAndAnalyzeNetworkPathResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
CreateAndAnalyzeNetworkPathResult::CreateAndAnalyzeNetworkPathResult() :
ServiceResult()
{}
CreateAndAnalyzeNetworkPathResult::CreateAndAnalyzeNetworkPathResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateAndAnalyzeNetworkPathResult::~CreateAndAnalyzeNetworkPathResult()
{}
void CreateAndAnalyzeNetworkPathResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["NetworkReachableAnalysisId"].isNull())
networkReachableAnalysisId_ = value["NetworkReachableAnalysisId"].asString();
if(!value["SourceId"].isNull())
sourceId_ = value["SourceId"].asString();
if(!value["TargetId"].isNull())
targetId_ = value["TargetId"].asString();
if(!value["SourceType"].isNull())
sourceType_ = value["SourceType"].asString();
if(!value["TargetType"].isNull())
targetType_ = value["TargetType"].asString();
if(!value["SourcePort"].isNull())
sourcePort_ = value["SourcePort"].asString();
if(!value["TargetPort"].isNull())
targetPort_ = value["TargetPort"].asString();
if(!value["Protocol"].isNull())
protocol_ = value["Protocol"].asString();
if(!value["SourceIpAddress"].isNull())
sourceIpAddress_ = value["SourceIpAddress"].asString();
if(!value["TargetIpAddress"].isNull())
targetIpAddress_ = value["TargetIpAddress"].asString();
}
std::string CreateAndAnalyzeNetworkPathResult::getTargetPort()const
{
return targetPort_;
}
std::string CreateAndAnalyzeNetworkPathResult::getNetworkReachableAnalysisId()const
{
return networkReachableAnalysisId_;
}
std::string CreateAndAnalyzeNetworkPathResult::getSourceId()const
{
return sourceId_;
}
std::string CreateAndAnalyzeNetworkPathResult::getSourceType()const
{
return sourceType_;
}
std::string CreateAndAnalyzeNetworkPathResult::getTargetType()const
{
return targetType_;
}
std::string CreateAndAnalyzeNetworkPathResult::getSourcePort()const
{
return sourcePort_;
}
std::string CreateAndAnalyzeNetworkPathResult::getProtocol()const
{
return protocol_;
}
std::string CreateAndAnalyzeNetworkPathResult::getTargetId()const
{
return targetId_;
}
std::string CreateAndAnalyzeNetworkPathResult::getSourceIpAddress()const
{
return sourceIpAddress_;
}
std::string CreateAndAnalyzeNetworkPathResult::getTargetIpAddress()const
{
return targetIpAddress_;
}

227
nis/src/model/CreateNetworkPathRequest.cc Normal file
View File

@@ -0,0 +1,227 @@
/*
* 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/nis/model/CreateNetworkPathRequest.h>
using AlibabaCloud::Nis::Model::CreateNetworkPathRequest;
CreateNetworkPathRequest::CreateNetworkPathRequest()
: RpcServiceRequest("nis", "2021-12-16", "CreateNetworkPath") {
setMethod(HttpRequest::Method::Post);
}
CreateNetworkPathRequest::~CreateNetworkPathRequest() {}
long CreateNetworkPathRequest::getResourceOwnerId() const {
return resourceOwnerId_;
}
void CreateNetworkPathRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::string CreateNetworkPathRequest::getTargetId() const {
return targetId_;
}
void CreateNetworkPathRequest::setTargetId(const std::string &targetId) {
targetId_ = targetId;
setParameter(std::string("TargetId"), targetId);
}
std::string CreateNetworkPathRequest::getTargetType() const {
return targetType_;
}
void CreateNetworkPathRequest::setTargetType(const std::string &targetType) {
targetType_ = targetType;
setParameter(std::string("TargetType"), targetType);
}
std::string CreateNetworkPathRequest::getClientToken() const {
return clientToken_;
}
void CreateNetworkPathRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::vector<CreateNetworkPathRequest::SystemTag> CreateNetworkPathRequest::getSystemTag() const {
return systemTag_;
}
void CreateNetworkPathRequest::setSystemTag(const std::vector<CreateNetworkPathRequest::SystemTag> &systemTag) {
systemTag_ = systemTag;
for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
auto systemTagObj = systemTag.at(dep1);
std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
setParameter(systemTagObjStr + ".Key", systemTagObj.key);
setParameter(systemTagObjStr + ".Value", systemTagObj.value);
setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
}
}
std::string CreateNetworkPathRequest::getTargetIpAddress() const {
return targetIpAddress_;
}
void CreateNetworkPathRequest::setTargetIpAddress(const std::string &targetIpAddress) {
targetIpAddress_ = targetIpAddress;
setParameter(std::string("TargetIpAddress"), targetIpAddress);
}
std::string CreateNetworkPathRequest::getNetworkPathName() const {
return networkPathName_;
}
void CreateNetworkPathRequest::setNetworkPathName(const std::string &networkPathName) {
networkPathName_ = networkPathName;
setParameter(std::string("NetworkPathName"), networkPathName);
}
int CreateNetworkPathRequest::getSourcePort() const {
return sourcePort_;
}
void CreateNetworkPathRequest::setSourcePort(int sourcePort) {
sourcePort_ = sourcePort;
setParameter(std::string("SourcePort"), std::to_string(sourcePort));
}
std::string CreateNetworkPathRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void CreateNetworkPathRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string CreateNetworkPathRequest::getProtocol() const {
return protocol_;
}
void CreateNetworkPathRequest::setProtocol(const std::string &protocol) {
protocol_ = protocol;
setParameter(std::string("Protocol"), protocol);
}
std::string CreateNetworkPathRequest::getRegionId() const {
return regionId_;
}
void CreateNetworkPathRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
long CreateNetworkPathRequest::getSourceAliUid() const {
return sourceAliUid_;
}
void CreateNetworkPathRequest::setSourceAliUid(long sourceAliUid) {
sourceAliUid_ = sourceAliUid;
setParameter(std::string("SourceAliUid"), std::to_string(sourceAliUid));
}
std::string CreateNetworkPathRequest::getSourceType() const {
return sourceType_;
}
void CreateNetworkPathRequest::setSourceType(const std::string &sourceType) {
sourceType_ = sourceType;
setParameter(std::string("SourceType"), sourceType);
}
std::vector<CreateNetworkPathRequest::Tag> CreateNetworkPathRequest::getTag() const {
return tag_;
}
void CreateNetworkPathRequest::setTag(const std::vector<CreateNetworkPathRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}
int CreateNetworkPathRequest::getTargetPort() const {
return targetPort_;
}
void CreateNetworkPathRequest::setTargetPort(int targetPort) {
targetPort_ = targetPort;
setParameter(std::string("TargetPort"), std::to_string(targetPort));
}
std::string CreateNetworkPathRequest::getSourceId() const {
return sourceId_;
}
void CreateNetworkPathRequest::setSourceId(const std::string &sourceId) {
sourceId_ = sourceId;
setParameter(std::string("SourceId"), sourceId);
}
std::string CreateNetworkPathRequest::getSourceIpAddress() const {
return sourceIpAddress_;
}
void CreateNetworkPathRequest::setSourceIpAddress(const std::string &sourceIpAddress) {
sourceIpAddress_ = sourceIpAddress;
setParameter(std::string("SourceIpAddress"), sourceIpAddress);
}
bool CreateNetworkPathRequest::getDryRun() const {
return dryRun_;
}
void CreateNetworkPathRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
bool CreateNetworkPathRequest::getUseMultiAccount() const {
return useMultiAccount_;
}
void CreateNetworkPathRequest::setUseMultiAccount(bool useMultiAccount) {
useMultiAccount_ = useMultiAccount;
setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
}
std::string CreateNetworkPathRequest::getNetworkPathDescription() const {
return networkPathDescription_;
}
void CreateNetworkPathRequest::setNetworkPathDescription(const std::string &networkPathDescription) {
networkPathDescription_ = networkPathDescription;
setParameter(std::string("NetworkPathDescription"), networkPathDescription);
}
long CreateNetworkPathRequest::getTargetAliUid() const {
return targetAliUid_;
}
void CreateNetworkPathRequest::setTargetAliUid(long targetAliUid) {
targetAliUid_ = targetAliUid;
setParameter(std::string("TargetAliUid"), std::to_string(targetAliUid));
}

51
nis/src/model/CreateNetworkPathResult.cc Normal file
View File

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

110
nis/src/model/CreateNetworkReachableAnalysisRequest.cc Normal file
View File

@@ -0,0 +1,110 @@
/*
* 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/nis/model/CreateNetworkReachableAnalysisRequest.h>
using AlibabaCloud::Nis::Model::CreateNetworkReachableAnalysisRequest;
CreateNetworkReachableAnalysisRequest::CreateNetworkReachableAnalysisRequest()
: RpcServiceRequest("nis", "2021-12-16", "CreateNetworkReachableAnalysis") {
setMethod(HttpRequest::Method::Post);
}
CreateNetworkReachableAnalysisRequest::~CreateNetworkReachableAnalysisRequest() {}
long CreateNetworkReachableAnalysisRequest::getResourceOwnerId() const {
return resourceOwnerId_;
}
void CreateNetworkReachableAnalysisRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
bool CreateNetworkReachableAnalysisRequest::getDryRun() const {
return dryRun_;
}
void CreateNetworkReachableAnalysisRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
std::string CreateNetworkReachableAnalysisRequest::getClientToken() const {
return clientToken_;
}
void CreateNetworkReachableAnalysisRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::vector<CreateNetworkReachableAnalysisRequest::SystemTag> CreateNetworkReachableAnalysisRequest::getSystemTag() const {
return systemTag_;
}
void CreateNetworkReachableAnalysisRequest::setSystemTag(const std::vector<CreateNetworkReachableAnalysisRequest::SystemTag> &systemTag) {
systemTag_ = systemTag;
for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
auto systemTagObj = systemTag.at(dep1);
std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
setParameter(systemTagObjStr + ".Key", systemTagObj.key);
setParameter(systemTagObjStr + ".Value", systemTagObj.value);
setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
}
}
std::string CreateNetworkReachableAnalysisRequest::getNetworkPathId() const {
return networkPathId_;
}
void CreateNetworkReachableAnalysisRequest::setNetworkPathId(const std::string &networkPathId) {
networkPathId_ = networkPathId;
setParameter(std::string("NetworkPathId"), networkPathId);
}
std::string CreateNetworkReachableAnalysisRequest::getRegionId() const {
return regionId_;
}
void CreateNetworkReachableAnalysisRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string CreateNetworkReachableAnalysisRequest::getAuditParam() const {
return auditParam_;
}
void CreateNetworkReachableAnalysisRequest::setAuditParam(const std::string &auditParam) {
auditParam_ = auditParam;
setParameter(std::string("AuditParam"), auditParam);
}
std::vector<CreateNetworkReachableAnalysisRequest::Tag> CreateNetworkReachableAnalysisRequest::getTag() const {
return tag_;
}
void CreateNetworkReachableAnalysisRequest::setTag(const std::vector<CreateNetworkReachableAnalysisRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}

51
nis/src/model/CreateNetworkReachableAnalysisResult.cc Normal file
View File

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

65
nis/src/model/DeleteNetworkPathRequest.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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/nis/model/DeleteNetworkPathRequest.h>
using AlibabaCloud::Nis::Model::DeleteNetworkPathRequest;
DeleteNetworkPathRequest::DeleteNetworkPathRequest()
: RpcServiceRequest("nis", "2021-12-16", "DeleteNetworkPath") {
setMethod(HttpRequest::Method::Post);
}
DeleteNetworkPathRequest::~DeleteNetworkPathRequest() {}
bool DeleteNetworkPathRequest::getDryRun() const {
return dryRun_;
}
void DeleteNetworkPathRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
std::string DeleteNetworkPathRequest::getClientToken() const {
return clientToken_;
}
void DeleteNetworkPathRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::vector<DeleteNetworkPathRequest::std::string> DeleteNetworkPathRequest::getNetworkPathIds() const {
return networkPathIds_;
}
void DeleteNetworkPathRequest::setNetworkPathIds(const std::vector<DeleteNetworkPathRequest::std::string> &networkPathIds) {
networkPathIds_ = networkPathIds;
for(int dep1 = 0; dep1 != networkPathIds.size(); dep1++) {
setParameter(std::string("NetworkPathIds") + "." + std::to_string(dep1 + 1), networkPathIds[dep1]);
}
}
std::string DeleteNetworkPathRequest::getRegionId() const {
return regionId_;
}
void DeleteNetworkPathRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}

51
nis/src/model/DeleteNetworkPathResult.cc Normal file
View File

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

65
nis/src/model/DeleteNetworkReachableAnalysisRequest.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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/nis/model/DeleteNetworkReachableAnalysisRequest.h>
using AlibabaCloud::Nis::Model::DeleteNetworkReachableAnalysisRequest;
DeleteNetworkReachableAnalysisRequest::DeleteNetworkReachableAnalysisRequest()
: RpcServiceRequest("nis", "2021-12-16", "DeleteNetworkReachableAnalysis") {
setMethod(HttpRequest::Method::Post);
}
DeleteNetworkReachableAnalysisRequest::~DeleteNetworkReachableAnalysisRequest() {}
bool DeleteNetworkReachableAnalysisRequest::getDryRun() const {
return dryRun_;
}
void DeleteNetworkReachableAnalysisRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
std::string DeleteNetworkReachableAnalysisRequest::getClientToken() const {
return clientToken_;
}
void DeleteNetworkReachableAnalysisRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::string DeleteNetworkReachableAnalysisRequest::getRegionId() const {
return regionId_;
}
void DeleteNetworkReachableAnalysisRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::vector<DeleteNetworkReachableAnalysisRequest::std::string> DeleteNetworkReachableAnalysisRequest::getNetworkReachableAnalysisIds() const {
return networkReachableAnalysisIds_;
}
void DeleteNetworkReachableAnalysisRequest::setNetworkReachableAnalysisIds(const std::vector<DeleteNetworkReachableAnalysisRequest::std::string> &networkReachableAnalysisIds) {
networkReachableAnalysisIds_ = networkReachableAnalysisIds;
for(int dep1 = 0; dep1 != networkReachableAnalysisIds.size(); dep1++) {
setParameter(std::string("NetworkReachableAnalysisIds") + "." + std::to_string(dep1 + 1), networkReachableAnalysisIds[dep1]);
}
}

51
nis/src/model/DeleteNetworkReachableAnalysisResult.cc Normal file
View File

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

228
nis/src/model/GetInternetTupleRequest.cc Normal file
View File

@@ -0,0 +1,228 @@
/*
* 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/nis/model/GetInternetTupleRequest.h>
using AlibabaCloud::Nis::Model::GetInternetTupleRequest;
GetInternetTupleRequest::GetInternetTupleRequest()
: RpcServiceRequest("nis", "2021-12-16", "GetInternetTuple") {
setMethod(HttpRequest::Method::Post);
}
GetInternetTupleRequest::~GetInternetTupleRequest() {}
std::string GetInternetTupleRequest::getOtherPort() const {
return otherPort_;
}
void GetInternetTupleRequest::setOtherPort(const std::string &otherPort) {
otherPort_ = otherPort;
setParameter(std::string("OtherPort"), otherPort);
}
std::string GetInternetTupleRequest::getCloudIsp() const {
return cloudIsp_;
}
void GetInternetTupleRequest::setCloudIsp(const std::string &cloudIsp) {
cloudIsp_ = cloudIsp;
setParameter(std::string("CloudIsp"), cloudIsp);
}
int GetInternetTupleRequest::getTopN() const {
return topN_;
}
void GetInternetTupleRequest::setTopN(int topN) {
topN_ = topN;
setParameter(std::string("TopN"), std::to_string(topN));
}
std::string GetInternetTupleRequest::getCloudPort() const {
return cloudPort_;
}
void GetInternetTupleRequest::setCloudPort(const std::string &cloudPort) {
cloudPort_ = cloudPort;
setParameter(std::string("CloudPort"), cloudPort);
}
std::string GetInternetTupleRequest::getProtocol() const {
return protocol_;
}
void GetInternetTupleRequest::setProtocol(const std::string &protocol) {
protocol_ = protocol;
setParameter(std::string("Protocol"), protocol);
}
std::string GetInternetTupleRequest::getOtherIp() const {
return otherIp_;
}
void GetInternetTupleRequest::setOtherIp(const std::string &otherIp) {
otherIp_ = otherIp;
setParameter(std::string("OtherIp"), otherIp);
}
std::vector<GetInternetTupleRequest::std::string> GetInternetTupleRequest::getInstanceList() const {
return instanceList_;
}
void GetInternetTupleRequest::setInstanceList(const std::vector<GetInternetTupleRequest::std::string> &instanceList) {
instanceList_ = instanceList;
for(int dep1 = 0; dep1 != instanceList.size(); dep1++) {
setParameter(std::string("InstanceList") + "." + std::to_string(dep1 + 1), instanceList[dep1]);
}
}
std::string GetInternetTupleRequest::getOrderBy() const {
return orderBy_;
}
void GetInternetTupleRequest::setOrderBy(const std::string &orderBy) {
orderBy_ = orderBy;
setParameter(std::string("OrderBy"), orderBy);
}
std::string GetInternetTupleRequest::getSort() const {
return sort_;
}
void GetInternetTupleRequest::setSort(const std::string &sort) {
sort_ = sort;
setParameter(std::string("Sort"), sort);
}
bool GetInternetTupleRequest::getUseMultiAccount() const {
return useMultiAccount_;
}
void GetInternetTupleRequest::setUseMultiAccount(bool useMultiAccount) {
useMultiAccount_ = useMultiAccount;
setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
}
std::string GetInternetTupleRequest::getInstanceId() const {
return instanceId_;
}
void GetInternetTupleRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
int GetInternetTupleRequest::getTupleType() const {
return tupleType_;
}
void GetInternetTupleRequest::setTupleType(int tupleType) {
tupleType_ = tupleType;
setParameter(std::string("TupleType"), std::to_string(tupleType));
}
std::string GetInternetTupleRequest::getCloudIp() const {
return cloudIp_;
}
void GetInternetTupleRequest::setCloudIp(const std::string &cloudIp) {
cloudIp_ = cloudIp;
setParameter(std::string("CloudIp"), cloudIp);
}
std::vector<GetInternetTupleRequest::std::string> GetInternetTupleRequest::getCloudIpList() const {
return cloudIpList_;
}
void GetInternetTupleRequest::setCloudIpList(const std::vector<GetInternetTupleRequest::std::string> &cloudIpList) {
cloudIpList_ = cloudIpList;
for(int dep1 = 0; dep1 != cloudIpList.size(); dep1++) {
setParameter(std::string("CloudIpList") + "." + std::to_string(dep1 + 1), cloudIpList[dep1]);
}
}
std::string GetInternetTupleRequest::getOtherIsp() const {
return otherIsp_;
}
void GetInternetTupleRequest::setOtherIsp(const std::string &otherIsp) {
otherIsp_ = otherIsp;
setParameter(std::string("OtherIsp"), otherIsp);
}
std::string GetInternetTupleRequest::getRegionId() const {
return regionId_;
}
void GetInternetTupleRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string GetInternetTupleRequest::getOtherCountry() const {
return otherCountry_;
}
void GetInternetTupleRequest::setOtherCountry(const std::string &otherCountry) {
otherCountry_ = otherCountry;
setParameter(std::string("OtherCountry"), otherCountry);
}
std::string GetInternetTupleRequest::getDirection() const {
return direction_;
}
void GetInternetTupleRequest::setDirection(const std::string &direction) {
direction_ = direction;
setParameter(std::string("Direction"), direction);
}
long GetInternetTupleRequest::getEndTime() const {
return endTime_;
}
void GetInternetTupleRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
long GetInternetTupleRequest::getBeginTime() const {
return beginTime_;
}
void GetInternetTupleRequest::setBeginTime(long beginTime) {
beginTime_ = beginTime;
setParameter(std::string("BeginTime"), std::to_string(beginTime));
}
std::string GetInternetTupleRequest::getOtherCity() const {
return otherCity_;
}
void GetInternetTupleRequest::setOtherCity(const std::string &otherCity) {
otherCity_ = otherCity;
setParameter(std::string("OtherCity"), otherCity);
}
std::vector<long> GetInternetTupleRequest::getAccountIds() const {
return accountIds_;
}
void GetInternetTupleRequest::setAccountIds(const std::vector<long> &accountIds) {
accountIds_ = accountIds;
}

121
nis/src/model/GetInternetTupleResult.cc Normal file
View File

@@ -0,0 +1,121 @@
/*
* 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/nis/model/GetInternetTupleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
GetInternetTupleResult::GetInternetTupleResult() :
ServiceResult()
{}
GetInternetTupleResult::GetInternetTupleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetInternetTupleResult::~GetInternetTupleResult()
{}
void GetInternetTupleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["DataItem"];
for (auto valueDataDataItem : allDataNode)
{
DataItem dataObject;
if(!valueDataDataItem["BeginTime"].isNull())
dataObject.beginTime = valueDataDataItem["BeginTime"].asString();
if(!valueDataDataItem["Direction"].isNull())
dataObject.direction = valueDataDataItem["Direction"].asString();
if(!valueDataDataItem["InstanceId"].isNull())
dataObject.instanceId = valueDataDataItem["InstanceId"].asString();
if(!valueDataDataItem["AccessRegion"].isNull())
dataObject.accessRegion = valueDataDataItem["AccessRegion"].asString();
if(!valueDataDataItem["CloudIp"].isNull())
dataObject.cloudIp = valueDataDataItem["CloudIp"].asString();
if(!valueDataDataItem["CloudPort"].isNull())
dataObject.cloudPort = valueDataDataItem["CloudPort"].asString();
if(!valueDataDataItem["OtherIp"].isNull())
dataObject.otherIp = valueDataDataItem["OtherIp"].asString();
if(!valueDataDataItem["OtherPort"].isNull())
dataObject.otherPort = valueDataDataItem["OtherPort"].asString();
if(!valueDataDataItem["Protocol"].isNull())
dataObject.protocol = valueDataDataItem["Protocol"].asString();
if(!valueDataDataItem["CloudCountry"].isNull())
dataObject.cloudCountry = valueDataDataItem["CloudCountry"].asString();
if(!valueDataDataItem["CloudProvince"].isNull())
dataObject.cloudProvince = valueDataDataItem["CloudProvince"].asString();
if(!valueDataDataItem["CloudCity"].isNull())
dataObject.cloudCity = valueDataDataItem["CloudCity"].asString();
if(!valueDataDataItem["CloudIsp"].isNull())
dataObject.cloudIsp = valueDataDataItem["CloudIsp"].asString();
if(!valueDataDataItem["CloudProduct"].isNull())
dataObject.cloudProduct = valueDataDataItem["CloudProduct"].asString();
if(!valueDataDataItem["OtherCountry"].isNull())
dataObject.otherCountry = valueDataDataItem["OtherCountry"].asString();
if(!valueDataDataItem["OtherProvince"].isNull())
dataObject.otherProvince = valueDataDataItem["OtherProvince"].asString();
if(!valueDataDataItem["OtherCity"].isNull())
dataObject.otherCity = valueDataDataItem["OtherCity"].asString();
if(!valueDataDataItem["OtherIsp"].isNull())
dataObject.otherIsp = valueDataDataItem["OtherIsp"].asString();
if(!valueDataDataItem["OtherProduct"].isNull())
dataObject.otherProduct = valueDataDataItem["OtherProduct"].asString();
if(!valueDataDataItem["Rtt"].isNull())
dataObject.rtt = valueDataDataItem["Rtt"].asString();
if(!valueDataDataItem["ByteCount"].isNull())
dataObject.byteCount = valueDataDataItem["ByteCount"].asString();
if(!valueDataDataItem["PacketCount"].isNull())
dataObject.packetCount = valueDataDataItem["PacketCount"].asString();
if(!valueDataDataItem["OutOrderCount"].isNull())
dataObject.outOrderCount = valueDataDataItem["OutOrderCount"].asString();
if(!valueDataDataItem["RetranCount"].isNull())
dataObject.retranCount = valueDataDataItem["RetranCount"].asString();
if(!valueDataDataItem["InByteCount"].isNull())
dataObject.inByteCount = valueDataDataItem["InByteCount"].asString();
if(!valueDataDataItem["OutByteCount"].isNull())
dataObject.outByteCount = valueDataDataItem["OutByteCount"].asString();
if(!valueDataDataItem["InPacketCount"].isNull())
dataObject.inPacketCount = valueDataDataItem["InPacketCount"].asString();
if(!valueDataDataItem["OutPacketCount"].isNull())
dataObject.outPacketCount = valueDataDataItem["OutPacketCount"].asString();
if(!valueDataDataItem["InOutOrderCount"].isNull())
dataObject.inOutOrderCount = valueDataDataItem["InOutOrderCount"].asString();
if(!valueDataDataItem["OutOutOrderCount"].isNull())
dataObject.outOutOrderCount = valueDataDataItem["OutOutOrderCount"].asString();
if(!valueDataDataItem["InRetranCount"].isNull())
dataObject.inRetranCount = valueDataDataItem["InRetranCount"].asString();
if(!valueDataDataItem["OutRetranCount"].isNull())
dataObject.outRetranCount = valueDataDataItem["OutRetranCount"].asString();
if(!valueDataDataItem["RetransmitRate"].isNull())
dataObject.retransmitRate = valueDataDataItem["RetransmitRate"].asString();
data_.push_back(dataObject);
}
}
std::vector<GetInternetTupleResult::DataItem> GetInternetTupleResult::getData()const
{
return data_;
}

90
nis/src/model/GetNatTopNRequest.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* 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/nis/model/GetNatTopNRequest.h>
using AlibabaCloud::Nis::Model::GetNatTopNRequest;
GetNatTopNRequest::GetNatTopNRequest()
: RpcServiceRequest("nis", "2021-12-16", "GetNatTopN") {
setMethod(HttpRequest::Method::Post);
}
GetNatTopNRequest::~GetNatTopNRequest() {}
std::string GetNatTopNRequest::getIp() const {
return ip_;
}
void GetNatTopNRequest::setIp(const std::string &ip) {
ip_ = ip;
setParameter(std::string("Ip"), ip);
}
long GetNatTopNRequest::getEndTime() const {
return endTime_;
}
void GetNatTopNRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
std::string GetNatTopNRequest::getOrderBy() const {
return orderBy_;
}
void GetNatTopNRequest::setOrderBy(const std::string &orderBy) {
orderBy_ = orderBy;
setParameter(std::string("OrderBy"), orderBy);
}
long GetNatTopNRequest::getBeginTime() const {
return beginTime_;
}
void GetNatTopNRequest::setBeginTime(long beginTime) {
beginTime_ = beginTime;
setParameter(std::string("BeginTime"), std::to_string(beginTime));
}
int GetNatTopNRequest::getTopN() const {
return topN_;
}
void GetNatTopNRequest::setTopN(int topN) {
topN_ = topN;
setParameter(std::string("TopN"), std::to_string(topN));
}
std::string GetNatTopNRequest::getRegionId() const {
return regionId_;
}
void GetNatTopNRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string GetNatTopNRequest::getNatGatewayId() const {
return natGatewayId_;
}
void GetNatTopNRequest::setNatGatewayId(const std::string &natGatewayId) {
natGatewayId_ = natGatewayId;
setParameter(std::string("NatGatewayId"), natGatewayId);
}

80
nis/src/model/GetNatTopNResult.cc 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.
*/
#include <alibabacloud/nis/model/GetNatTopNResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
GetNatTopNResult::GetNatTopNResult() :
ServiceResult()
{}
GetNatTopNResult::GetNatTopNResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetNatTopNResult::~GetNatTopNResult()
{}
void GetNatTopNResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allNatGatewayTopNNode = value["NatGatewayTopN"]["NatGatewayTopNItem"];
for (auto valueNatGatewayTopNNatGatewayTopNItem : allNatGatewayTopNNode)
{
NatGatewayTopNItem natGatewayTopNObject;
if(!valueNatGatewayTopNNatGatewayTopNItem["Ip"].isNull())
natGatewayTopNObject.ip = valueNatGatewayTopNNatGatewayTopNItem["Ip"].asString();
if(!valueNatGatewayTopNNatGatewayTopNItem["InBps"].isNull())
natGatewayTopNObject.inBps = std::stof(valueNatGatewayTopNNatGatewayTopNItem["InBps"].asString());
if(!valueNatGatewayTopNNatGatewayTopNItem["OutBps"].isNull())
natGatewayTopNObject.outBps = std::stof(valueNatGatewayTopNNatGatewayTopNItem["OutBps"].asString());
if(!valueNatGatewayTopNNatGatewayTopNItem["InPps"].isNull())
natGatewayTopNObject.inPps = std::stof(valueNatGatewayTopNNatGatewayTopNItem["InPps"].asString());
if(!valueNatGatewayTopNNatGatewayTopNItem["OutPps"].isNull())
natGatewayTopNObject.outPps = std::stof(valueNatGatewayTopNNatGatewayTopNItem["OutPps"].asString());
if(!valueNatGatewayTopNNatGatewayTopNItem["InFlowPerMinute"].isNull())
natGatewayTopNObject.inFlowPerMinute = std::stof(valueNatGatewayTopNNatGatewayTopNItem["InFlowPerMinute"].asString());
if(!valueNatGatewayTopNNatGatewayTopNItem["OutFlowPerMinute"].isNull())
natGatewayTopNObject.outFlowPerMinute = std::stof(valueNatGatewayTopNNatGatewayTopNItem["OutFlowPerMinute"].asString());
if(!valueNatGatewayTopNNatGatewayTopNItem["NewSessionPerSecond"].isNull())
natGatewayTopNObject.newSessionPerSecond = std::stof(valueNatGatewayTopNNatGatewayTopNItem["NewSessionPerSecond"].asString());
if(!valueNatGatewayTopNNatGatewayTopNItem["ActiveSessionCount"].isNull())
natGatewayTopNObject.activeSessionCount = std::stof(valueNatGatewayTopNNatGatewayTopNItem["ActiveSessionCount"].asString());
natGatewayTopN_.push_back(natGatewayTopNObject);
}
if(!value["IsTopNOpen"].isNull())
isTopNOpen_ = value["IsTopNOpen"].asString() == "true";
}
std::vector<GetNatTopNResult::NatGatewayTopNItem> GetNatTopNResult::getNatGatewayTopN()const
{
return natGatewayTopN_;
}
bool GetNatTopNResult::getIsTopNOpen()const
{
return isTopNOpen_;
}

45
nis/src/model/GetNetworkReachableAnalysisRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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/nis/model/GetNetworkReachableAnalysisRequest.h>
using AlibabaCloud::Nis::Model::GetNetworkReachableAnalysisRequest;
GetNetworkReachableAnalysisRequest::GetNetworkReachableAnalysisRequest()
: RpcServiceRequest("nis", "2021-12-16", "GetNetworkReachableAnalysis") {
setMethod(HttpRequest::Method::Post);
}
GetNetworkReachableAnalysisRequest::~GetNetworkReachableAnalysisRequest() {}
std::string GetNetworkReachableAnalysisRequest::getNetworkReachableAnalysisId() const {
return networkReachableAnalysisId_;
}
void GetNetworkReachableAnalysisRequest::setNetworkReachableAnalysisId(const std::string &networkReachableAnalysisId) {
networkReachableAnalysisId_ = networkReachableAnalysisId;
setParameter(std::string("NetworkReachableAnalysisId"), networkReachableAnalysisId);
}
std::string GetNetworkReachableAnalysisRequest::getRegionId() const {
return regionId_;
}
void GetNetworkReachableAnalysisRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}

100
nis/src/model/GetNetworkReachableAnalysisResult.cc Normal file
View File

@@ -0,0 +1,100 @@
/*
* 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/nis/model/GetNetworkReachableAnalysisResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
GetNetworkReachableAnalysisResult::GetNetworkReachableAnalysisResult() :
ServiceResult()
{}
GetNetworkReachableAnalysisResult::GetNetworkReachableAnalysisResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetNetworkReachableAnalysisResult::~GetNetworkReachableAnalysisResult()
{}
void GetNetworkReachableAnalysisResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["NetworkPathId"].isNull())
networkPathId_ = value["NetworkPathId"].asString();
if(!value["NetworkReachableAnalysisId"].isNull())
networkReachableAnalysisId_ = value["NetworkReachableAnalysisId"].asString();
if(!value["NetworkReachableAnalysisStatus"].isNull())
networkReachableAnalysisStatus_ = value["NetworkReachableAnalysisStatus"].asString();
if(!value["NetworkReachableAnalysisResult"].isNull())
networkReachableAnalysisResult_ = value["NetworkReachableAnalysisResult"].asString();
if(!value["Reachable"].isNull())
reachable_ = value["Reachable"].asString() == "true";
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["AliUid"].isNull())
aliUid_ = std::stol(value["AliUid"].asString());
if(!value["NetworkPathParameter"].isNull())
networkPathParameter_ = value["NetworkPathParameter"].asString();
}
std::string GetNetworkReachableAnalysisResult::getNetworkReachableAnalysisId()const
{
return networkReachableAnalysisId_;
}
std::string GetNetworkReachableAnalysisResult::getCreateTime()const
{
return createTime_;
}
bool GetNetworkReachableAnalysisResult::getReachable()const
{
return reachable_;
}
std::string GetNetworkReachableAnalysisResult::getNetworkPathId()const
{
return networkPathId_;
}
std::string GetNetworkReachableAnalysisResult::getNetworkReachableAnalysisResult()const
{
return networkReachableAnalysisResult_;
}
std::string GetNetworkReachableAnalysisResult::getNetworkReachableAnalysisStatus()const
{
return networkReachableAnalysisStatus_;
}
long GetNetworkReachableAnalysisResult::getAliUid()const
{
return aliUid_;
}
std::string GetNetworkReachableAnalysisResult::getNetworkPathParameter()const
{
return networkPathParameter_;
}

110
nis/src/model/GetNisNetworkMetricsRequest.cc Normal file
View File

@@ -0,0 +1,110 @@
/*
* 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/nis/model/GetNisNetworkMetricsRequest.h>
using AlibabaCloud::Nis::Model::GetNisNetworkMetricsRequest;
GetNisNetworkMetricsRequest::GetNisNetworkMetricsRequest()
: RpcServiceRequest("nis", "2021-12-16", "GetNisNetworkMetrics") {
setMethod(HttpRequest::Method::Post);
}
GetNisNetworkMetricsRequest::~GetNisNetworkMetricsRequest() {}
bool GetNisNetworkMetricsRequest::getUseCrossAccount() const {
return useCrossAccount_;
}
void GetNisNetworkMetricsRequest::setUseCrossAccount(bool useCrossAccount) {
useCrossAccount_ = useCrossAccount;
setParameter(std::string("UseCrossAccount"), useCrossAccount ? "true" : "false");
}
std::string GetNisNetworkMetricsRequest::getScanBy() const {
return scanBy_;
}
void GetNisNetworkMetricsRequest::setScanBy(const std::string &scanBy) {
scanBy_ = scanBy;
setParameter(std::string("ScanBy"), scanBy);
}
std::string GetNisNetworkMetricsRequest::getMetricName() const {
return metricName_;
}
void GetNisNetworkMetricsRequest::setMetricName(const std::string &metricName) {
metricName_ = metricName;
setParameter(std::string("MetricName"), metricName);
}
long GetNisNetworkMetricsRequest::getEndTime() const {
return endTime_;
}
void GetNisNetworkMetricsRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
long GetNisNetworkMetricsRequest::getBeginTime() const {
return beginTime_;
}
void GetNisNetworkMetricsRequest::setBeginTime(long beginTime) {
beginTime_ = beginTime;
setParameter(std::string("BeginTime"), std::to_string(beginTime));
}
std::string GetNisNetworkMetricsRequest::getResourceType() const {
return resourceType_;
}
void GetNisNetworkMetricsRequest::setResourceType(const std::string &resourceType) {
resourceType_ = resourceType;
setParameter(std::string("ResourceType"), resourceType);
}
std::string GetNisNetworkMetricsRequest::getRegionNo() const {
return regionNo_;
}
void GetNisNetworkMetricsRequest::setRegionNo(const std::string &regionNo) {
regionNo_ = regionNo;
setParameter(std::string("RegionNo"), regionNo);
}
std::vector<std::string> GetNisNetworkMetricsRequest::getAccountIds() const {
return accountIds_;
}
void GetNisNetworkMetricsRequest::setAccountIds(const std::vector<std::string> &accountIds) {
accountIds_ = accountIds;
}
std::vector<GetNisNetworkMetricsRequest::Dimensions> GetNisNetworkMetricsRequest::getDimensions() const {
return dimensions_;
}
void GetNisNetworkMetricsRequest::setDimensions(const std::vector<GetNisNetworkMetricsRequest::Dimensions> &dimensions) {
dimensions_ = dimensions;
for(int dep1 = 0; dep1 != dimensions.size(); dep1++) {
setParameter(std::string("Dimensions") + "." + std::to_string(dep1 + 1) + ".Name", dimensions[dep1].name);
setParameter(std::string("Dimensions") + "." + std::to_string(dep1 + 1) + ".Value", dimensions[dep1].value);
}
}

62
nis/src/model/GetNisNetworkMetricsResult.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/nis/model/GetNisNetworkMetricsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
GetNisNetworkMetricsResult::GetNisNetworkMetricsResult() :
ServiceResult()
{}
GetNisNetworkMetricsResult::GetNisNetworkMetricsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetNisNetworkMetricsResult::~GetNisNetworkMetricsResult()
{}
void GetNisNetworkMetricsResult::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["Unit"].isNull())
data_.unit = dataNode["Unit"].asString();
auto allMetricsNode = dataNode["Metrics"]["MetricsItem"];
for (auto dataNodeMetricsMetricsItem : allMetricsNode)
{
Data::MetricsItem metricsItemObject;
if(!dataNodeMetricsMetricsItem["TimeStamp"].isNull())
metricsItemObject.timeStamp = std::stol(dataNodeMetricsMetricsItem["TimeStamp"].asString());
if(!dataNodeMetricsMetricsItem["Value"].isNull())
metricsItemObject.value = dataNodeMetricsMetricsItem["Value"].asString();
data_.metrics.push_back(metricsItemObject);
}
}
GetNisNetworkMetricsResult::Data GetNisNetworkMetricsResult::getData()const
{
return data_;
}

137
nis/src/model/GetNisNetworkRankingRequest.cc Normal file
View File

@@ -0,0 +1,137 @@
/*
* 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/nis/model/GetNisNetworkRankingRequest.h>
using AlibabaCloud::Nis::Model::GetNisNetworkRankingRequest;
GetNisNetworkRankingRequest::GetNisNetworkRankingRequest()
: RpcServiceRequest("nis", "2021-12-16", "GetNisNetworkRanking") {
setMethod(HttpRequest::Method::Post);
}
GetNisNetworkRankingRequest::~GetNisNetworkRankingRequest() {}
bool GetNisNetworkRankingRequest::getUseCrossAccount() const {
return useCrossAccount_;
}
void GetNisNetworkRankingRequest::setUseCrossAccount(bool useCrossAccount) {
useCrossAccount_ = useCrossAccount;
setParameter(std::string("UseCrossAccount"), useCrossAccount ? "true" : "false");
}
int GetNisNetworkRankingRequest::getTopN() const {
return topN_;
}
void GetNisNetworkRankingRequest::setTopN(int topN) {
topN_ = topN;
setParameter(std::string("TopN"), std::to_string(topN));
}
std::string GetNisNetworkRankingRequest::getDirection() const {
return direction_;
}
void GetNisNetworkRankingRequest::setDirection(const std::string &direction) {
direction_ = direction;
setParameter(std::string("Direction"), direction);
}
std::string GetNisNetworkRankingRequest::getOrderBy() const {
return orderBy_;
}
void GetNisNetworkRankingRequest::setOrderBy(const std::string &orderBy) {
orderBy_ = orderBy;
setParameter(std::string("OrderBy"), orderBy);
}
long GetNisNetworkRankingRequest::getEndTime() const {
return endTime_;
}
void GetNisNetworkRankingRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
long GetNisNetworkRankingRequest::getBeginTime() const {
return beginTime_;
}
void GetNisNetworkRankingRequest::setBeginTime(long beginTime) {
beginTime_ = beginTime;
setParameter(std::string("BeginTime"), std::to_string(beginTime));
}
std::string GetNisNetworkRankingRequest::getGroupBy() const {
return groupBy_;
}
void GetNisNetworkRankingRequest::setGroupBy(const std::string &groupBy) {
groupBy_ = groupBy;
setParameter(std::string("GroupBy"), groupBy);
}
std::string GetNisNetworkRankingRequest::getSort() const {
return sort_;
}
void GetNisNetworkRankingRequest::setSort(const std::string &sort) {
sort_ = sort;
setParameter(std::string("Sort"), sort);
}
std::string GetNisNetworkRankingRequest::getResourceType() const {
return resourceType_;
}
void GetNisNetworkRankingRequest::setResourceType(const std::string &resourceType) {
resourceType_ = resourceType;
setParameter(std::string("ResourceType"), resourceType);
}
std::string GetNisNetworkRankingRequest::getRegionNo() const {
return regionNo_;
}
void GetNisNetworkRankingRequest::setRegionNo(const std::string &regionNo) {
regionNo_ = regionNo;
setParameter(std::string("RegionNo"), regionNo);
}
std::vector<GetNisNetworkRankingRequest::Filter> GetNisNetworkRankingRequest::getFilter() const {
return filter_;
}
void GetNisNetworkRankingRequest::setFilter(const std::vector<GetNisNetworkRankingRequest::Filter> &filter) {
filter_ = filter;
for(int dep1 = 0; dep1 != filter.size(); dep1++) {
setParameter(std::string("Filter") + "." + std::to_string(dep1 + 1) + ".Name", filter[dep1].name);
setParameter(std::string("Filter") + "." + std::to_string(dep1 + 1) + ".Value", filter[dep1].value);
}
}
std::vector<std::string> GetNisNetworkRankingRequest::getAccountIds() const {
return accountIds_;
}
void GetNisNetworkRankingRequest::setAccountIds(const std::vector<std::string> &accountIds) {
accountIds_ = accountIds;
}

117
nis/src/model/GetNisNetworkRankingResult.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/nis/model/GetNisNetworkRankingResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
GetNisNetworkRankingResult::GetNisNetworkRankingResult() :
ServiceResult()
{}
GetNisNetworkRankingResult::GetNisNetworkRankingResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetNisNetworkRankingResult::~GetNisNetworkRankingResult()
{}
void GetNisNetworkRankingResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["Rankings"];
for (auto valueDataRankings : allDataNode)
{
Rankings dataObject;
if(!valueDataRankings["RegionNo"].isNull())
dataObject.regionNo = valueDataRankings["RegionNo"].asString();
if(!valueDataRankings["InstanceId"].isNull())
dataObject.instanceId = valueDataRankings["InstanceId"].asString();
if(!valueDataRankings["BandwidthPackageId"].isNull())
dataObject.bandwidthPackageId = valueDataRankings["BandwidthPackageId"].asString();
if(!valueDataRankings["SourceIp"].isNull())
dataObject.sourceIp = valueDataRankings["SourceIp"].asString();
if(!valueDataRankings["SourcePort"].isNull())
dataObject.sourcePort = valueDataRankings["SourcePort"].asString();
if(!valueDataRankings["SourceIsp"].isNull())
dataObject.sourceIsp = valueDataRankings["SourceIsp"].asString();
if(!valueDataRankings["DestinationIp"].isNull())
dataObject.destinationIp = valueDataRankings["DestinationIp"].asString();
if(!valueDataRankings["DestinationPort"].isNull())
dataObject.destinationPort = valueDataRankings["DestinationPort"].asString();
if(!valueDataRankings["DestinationIsp"].isNull())
dataObject.destinationIsp = valueDataRankings["DestinationIsp"].asString();
if(!valueDataRankings["Protocol"].isNull())
dataObject.protocol = valueDataRankings["Protocol"].asString();
if(!valueDataRankings["Country"].isNull())
dataObject.country = valueDataRankings["Country"].asString();
if(!valueDataRankings["Province"].isNull())
dataObject.province = valueDataRankings["Province"].asString();
if(!valueDataRankings["City"].isNull())
dataObject.city = valueDataRankings["City"].asString();
if(!valueDataRankings["Isp"].isNull())
dataObject.isp = valueDataRankings["Isp"].asString();
if(!valueDataRankings["Asn"].isNull())
dataObject.asn = valueDataRankings["Asn"].asString();
if(!valueDataRankings["IP"].isNull())
dataObject.iP = valueDataRankings["IP"].asString();
if(!valueDataRankings["DestinationRegionNo"].isNull())
dataObject.destinationRegionNo = valueDataRankings["DestinationRegionNo"].asString();
if(!valueDataRankings["VbrId"].isNull())
dataObject.vbrId = valueDataRankings["VbrId"].asString();
if(!valueDataRankings["AttachmentId"].isNull())
dataObject.attachmentId = valueDataRankings["AttachmentId"].asString();
if(!valueDataRankings["SourceZone"].isNull())
dataObject.sourceZone = valueDataRankings["SourceZone"].asString();
if(!valueDataRankings["DestinationZone"].isNull())
dataObject.destinationZone = valueDataRankings["DestinationZone"].asString();
if(!valueDataRankings["ByteCount"].isNull())
dataObject.byteCount = valueDataRankings["ByteCount"].asString();
if(!valueDataRankings["PacketCount"].isNull())
dataObject.packetCount = valueDataRankings["PacketCount"].asString();
if(!valueDataRankings["RTT"].isNull())
dataObject.rTT = valueDataRankings["RTT"].asString();
if(!valueDataRankings["RetransmitRate"].isNull())
dataObject.retransmitRate = valueDataRankings["RetransmitRate"].asString();
if(!valueDataRankings["InBps"].isNull())
dataObject.inBps = valueDataRankings["InBps"].asString();
if(!valueDataRankings["InPps"].isNull())
dataObject.inPps = valueDataRankings["InPps"].asString();
if(!valueDataRankings["OutBps"].isNull())
dataObject.outBps = valueDataRankings["OutBps"].asString();
if(!valueDataRankings["OutPps"].isNull())
dataObject.outPps = valueDataRankings["OutPps"].asString();
if(!valueDataRankings["NewSessionPerSecond"].isNull())
dataObject.newSessionPerSecond = valueDataRankings["NewSessionPerSecond"].asString();
if(!valueDataRankings["ActiveSessionCount"].isNull())
dataObject.activeSessionCount = valueDataRankings["ActiveSessionCount"].asString();
data_.push_back(dataObject);
}
}
std::vector<GetNisNetworkRankingResult::Rankings> GetNisNetworkRankingResult::getData()const
{
return data_;
}

191
nis/src/model/GetTransitRouterFlowTopNRequest.cc Normal file
View File

@@ -0,0 +1,191 @@
/*
* 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/nis/model/GetTransitRouterFlowTopNRequest.h>
using AlibabaCloud::Nis::Model::GetTransitRouterFlowTopNRequest;
GetTransitRouterFlowTopNRequest::GetTransitRouterFlowTopNRequest()
: RpcServiceRequest("nis", "2021-12-16", "GetTransitRouterFlowTopN") {
setMethod(HttpRequest::Method::Post);
}
GetTransitRouterFlowTopNRequest::~GetTransitRouterFlowTopNRequest() {}
std::string GetTransitRouterFlowTopNRequest::getOtherPort() const {
return otherPort_;
}
void GetTransitRouterFlowTopNRequest::setOtherPort(const std::string &otherPort) {
otherPort_ = otherPort;
setParameter(std::string("OtherPort"), otherPort);
}
int GetTransitRouterFlowTopNRequest::getTopN() const {
return topN_;
}
void GetTransitRouterFlowTopNRequest::setTopN(int topN) {
topN_ = topN;
setParameter(std::string("TopN"), std::to_string(topN));
}
std::string GetTransitRouterFlowTopNRequest::getProtocol() const {
return protocol_;
}
void GetTransitRouterFlowTopNRequest::setProtocol(const std::string &protocol) {
protocol_ = protocol;
setParameter(std::string("Protocol"), protocol);
}
std::string GetTransitRouterFlowTopNRequest::getThisIp() const {
return thisIp_;
}
void GetTransitRouterFlowTopNRequest::setThisIp(const std::string &thisIp) {
thisIp_ = thisIp;
setParameter(std::string("ThisIp"), thisIp);
}
std::string GetTransitRouterFlowTopNRequest::getOtherIp() const {
return otherIp_;
}
void GetTransitRouterFlowTopNRequest::setOtherIp(const std::string &otherIp) {
otherIp_ = otherIp;
setParameter(std::string("OtherIp"), otherIp);
}
std::string GetTransitRouterFlowTopNRequest::getBandwithPackageId() const {
return bandwithPackageId_;
}
void GetTransitRouterFlowTopNRequest::setBandwithPackageId(const std::string &bandwithPackageId) {
bandwithPackageId_ = bandwithPackageId;
setParameter(std::string("BandwithPackageId"), bandwithPackageId);
}
std::string GetTransitRouterFlowTopNRequest::getOrderBy() const {
return orderBy_;
}
void GetTransitRouterFlowTopNRequest::setOrderBy(const std::string &orderBy) {
orderBy_ = orderBy;
setParameter(std::string("OrderBy"), orderBy);
}
std::string GetTransitRouterFlowTopNRequest::getSort() const {
return sort_;
}
void GetTransitRouterFlowTopNRequest::setSort(const std::string &sort) {
sort_ = sort;
setParameter(std::string("Sort"), sort);
}
bool GetTransitRouterFlowTopNRequest::getUseMultiAccount() const {
return useMultiAccount_;
}
void GetTransitRouterFlowTopNRequest::setUseMultiAccount(bool useMultiAccount) {
useMultiAccount_ = useMultiAccount;
setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
}
std::string GetTransitRouterFlowTopNRequest::getThisRegion() const {
return thisRegion_;
}
void GetTransitRouterFlowTopNRequest::setThisRegion(const std::string &thisRegion) {
thisRegion_ = thisRegion;
setParameter(std::string("ThisRegion"), thisRegion);
}
std::string GetTransitRouterFlowTopNRequest::getCenId() const {
return cenId_;
}
void GetTransitRouterFlowTopNRequest::setCenId(const std::string &cenId) {
cenId_ = cenId;
setParameter(std::string("CenId"), cenId);
}
std::string GetTransitRouterFlowTopNRequest::getThisPort() const {
return thisPort_;
}
void GetTransitRouterFlowTopNRequest::setThisPort(const std::string &thisPort) {
thisPort_ = thisPort;
setParameter(std::string("ThisPort"), thisPort);
}
std::string GetTransitRouterFlowTopNRequest::getDirection() const {
return direction_;
}
void GetTransitRouterFlowTopNRequest::setDirection(const std::string &direction) {
direction_ = direction;
setParameter(std::string("Direction"), direction);
}
std::string GetTransitRouterFlowTopNRequest::getOtherRegion() const {
return otherRegion_;
}
void GetTransitRouterFlowTopNRequest::setOtherRegion(const std::string &otherRegion) {
otherRegion_ = otherRegion;
setParameter(std::string("OtherRegion"), otherRegion);
}
long GetTransitRouterFlowTopNRequest::getEndTime() const {
return endTime_;
}
void GetTransitRouterFlowTopNRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
long GetTransitRouterFlowTopNRequest::getBeginTime() const {
return beginTime_;
}
void GetTransitRouterFlowTopNRequest::setBeginTime(long beginTime) {
beginTime_ = beginTime;
setParameter(std::string("BeginTime"), std::to_string(beginTime));
}
std::string GetTransitRouterFlowTopNRequest::getGroupBy() const {
return groupBy_;
}
void GetTransitRouterFlowTopNRequest::setGroupBy(const std::string &groupBy) {
groupBy_ = groupBy;
setParameter(std::string("GroupBy"), groupBy);
}
std::vector<GetTransitRouterFlowTopNRequest::long> GetTransitRouterFlowTopNRequest::getAccountIds() const {
return accountIds_;
}
void GetTransitRouterFlowTopNRequest::setAccountIds(const std::vector<GetTransitRouterFlowTopNRequest::long> &accountIds) {
accountIds_ = accountIds;
for(int dep1 = 0; dep1 != accountIds.size(); dep1++) {
setParameter(std::string("AccountIds") + "." + std::to_string(dep1 + 1), std::to_string(accountIds[dep1]));
}
}

83
nis/src/model/GetTransitRouterFlowTopNResult.cc Normal file
View File

@@ -0,0 +1,83 @@
/*
* 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/nis/model/GetTransitRouterFlowTopNResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
GetTransitRouterFlowTopNResult::GetTransitRouterFlowTopNResult() :
ServiceResult()
{}
GetTransitRouterFlowTopNResult::GetTransitRouterFlowTopNResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetTransitRouterFlowTopNResult::~GetTransitRouterFlowTopNResult()
{}
void GetTransitRouterFlowTopNResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTransitRouterFlowTopNNode = value["TransitRouterFlowTopN"]["TrFlowlogTopN"];
for (auto valueTransitRouterFlowTopNTrFlowlogTopN : allTransitRouterFlowTopNNode)
{
TrFlowlogTopN transitRouterFlowTopNObject;
if(!valueTransitRouterFlowTopNTrFlowlogTopN["AccountId"].isNull())
transitRouterFlowTopNObject.accountId = valueTransitRouterFlowTopNTrFlowlogTopN["AccountId"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["CenId"].isNull())
transitRouterFlowTopNObject.cenId = valueTransitRouterFlowTopNTrFlowlogTopN["CenId"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["ThisRegion"].isNull())
transitRouterFlowTopNObject.thisRegion = valueTransitRouterFlowTopNTrFlowlogTopN["ThisRegion"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["ThisIp"].isNull())
transitRouterFlowTopNObject.thisIp = valueTransitRouterFlowTopNTrFlowlogTopN["ThisIp"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["ThisPort"].isNull())
transitRouterFlowTopNObject.thisPort = valueTransitRouterFlowTopNTrFlowlogTopN["ThisPort"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["OtherRegion"].isNull())
transitRouterFlowTopNObject.otherRegion = valueTransitRouterFlowTopNTrFlowlogTopN["OtherRegion"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["OtherIp"].isNull())
transitRouterFlowTopNObject.otherIp = valueTransitRouterFlowTopNTrFlowlogTopN["OtherIp"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["OtherPort"].isNull())
transitRouterFlowTopNObject.otherPort = valueTransitRouterFlowTopNTrFlowlogTopN["OtherPort"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["Protocol"].isNull())
transitRouterFlowTopNObject.protocol = valueTransitRouterFlowTopNTrFlowlogTopN["Protocol"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["StartTime"].isNull())
transitRouterFlowTopNObject.startTime = valueTransitRouterFlowTopNTrFlowlogTopN["StartTime"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["EndTime"].isNull())
transitRouterFlowTopNObject.endTime = valueTransitRouterFlowTopNTrFlowlogTopN["EndTime"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["Packets"].isNull())
transitRouterFlowTopNObject.packets = valueTransitRouterFlowTopNTrFlowlogTopN["Packets"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["Bytes"].isNull())
transitRouterFlowTopNObject.bytes = valueTransitRouterFlowTopNTrFlowlogTopN["Bytes"].asString();
if(!valueTransitRouterFlowTopNTrFlowlogTopN["BandwithPackageId"].isNull())
transitRouterFlowTopNObject.bandwithPackageId = valueTransitRouterFlowTopNTrFlowlogTopN["BandwithPackageId"].asString();
transitRouterFlowTopN_.push_back(transitRouterFlowTopNObject);
}
}
std::vector<GetTransitRouterFlowTopNResult::TrFlowlogTopN> GetTransitRouterFlowTopNResult::getTransitRouterFlowTopN()const
{
return transitRouterFlowTopN_;
}

191
nis/src/model/GetVbrFlowTopNRequest.cc Normal file
View File

@@ -0,0 +1,191 @@
/*
* 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/nis/model/GetVbrFlowTopNRequest.h>
using AlibabaCloud::Nis::Model::GetVbrFlowTopNRequest;
GetVbrFlowTopNRequest::GetVbrFlowTopNRequest()
: RpcServiceRequest("nis", "2021-12-16", "GetVbrFlowTopN") {
setMethod(HttpRequest::Method::Post);
}
GetVbrFlowTopNRequest::~GetVbrFlowTopNRequest() {}
std::string GetVbrFlowTopNRequest::getOtherPort() const {
return otherPort_;
}
void GetVbrFlowTopNRequest::setOtherPort(const std::string &otherPort) {
otherPort_ = otherPort;
setParameter(std::string("OtherPort"), otherPort);
}
int GetVbrFlowTopNRequest::getTopN() const {
return topN_;
}
void GetVbrFlowTopNRequest::setTopN(int topN) {
topN_ = topN;
setParameter(std::string("TopN"), std::to_string(topN));
}
std::string GetVbrFlowTopNRequest::getCloudPort() const {
return cloudPort_;
}
void GetVbrFlowTopNRequest::setCloudPort(const std::string &cloudPort) {
cloudPort_ = cloudPort;
setParameter(std::string("CloudPort"), cloudPort);
}
std::string GetVbrFlowTopNRequest::getProtocol() const {
return protocol_;
}
void GetVbrFlowTopNRequest::setProtocol(const std::string &protocol) {
protocol_ = protocol;
setParameter(std::string("Protocol"), protocol);
}
std::string GetVbrFlowTopNRequest::getOtherIp() const {
return otherIp_;
}
void GetVbrFlowTopNRequest::setOtherIp(const std::string &otherIp) {
otherIp_ = otherIp;
setParameter(std::string("OtherIp"), otherIp);
}
std::string GetVbrFlowTopNRequest::getOrderBy() const {
return orderBy_;
}
void GetVbrFlowTopNRequest::setOrderBy(const std::string &orderBy) {
orderBy_ = orderBy;
setParameter(std::string("OrderBy"), orderBy);
}
std::string GetVbrFlowTopNRequest::getSort() const {
return sort_;
}
void GetVbrFlowTopNRequest::setSort(const std::string &sort) {
sort_ = sort;
setParameter(std::string("Sort"), sort);
}
bool GetVbrFlowTopNRequest::getUseMultiAccount() const {
return useMultiAccount_;
}
void GetVbrFlowTopNRequest::setUseMultiAccount(bool useMultiAccount) {
useMultiAccount_ = useMultiAccount;
setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
}
std::string GetVbrFlowTopNRequest::getCloudIp() const {
return cloudIp_;
}
void GetVbrFlowTopNRequest::setCloudIp(const std::string &cloudIp) {
cloudIp_ = cloudIp;
setParameter(std::string("CloudIp"), cloudIp);
}
std::string GetVbrFlowTopNRequest::getCenId() const {
return cenId_;
}
void GetVbrFlowTopNRequest::setCenId(const std::string &cenId) {
cenId_ = cenId;
setParameter(std::string("CenId"), cenId);
}
std::string GetVbrFlowTopNRequest::getRegionId() const {
return regionId_;
}
void GetVbrFlowTopNRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string GetVbrFlowTopNRequest::getVirtualBorderRouterId() const {
return virtualBorderRouterId_;
}
void GetVbrFlowTopNRequest::setVirtualBorderRouterId(const std::string &virtualBorderRouterId) {
virtualBorderRouterId_ = virtualBorderRouterId;
setParameter(std::string("VirtualBorderRouterId"), virtualBorderRouterId);
}
std::string GetVbrFlowTopNRequest::getDirection() const {
return direction_;
}
void GetVbrFlowTopNRequest::setDirection(const std::string &direction) {
direction_ = direction;
setParameter(std::string("Direction"), direction);
}
long GetVbrFlowTopNRequest::getEndTime() const {
return endTime_;
}
void GetVbrFlowTopNRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
long GetVbrFlowTopNRequest::getBeginTime() const {
return beginTime_;
}
void GetVbrFlowTopNRequest::setBeginTime(long beginTime) {
beginTime_ = beginTime;
setParameter(std::string("BeginTime"), std::to_string(beginTime));
}
std::string GetVbrFlowTopNRequest::getGroupBy() const {
return groupBy_;
}
void GetVbrFlowTopNRequest::setGroupBy(const std::string &groupBy) {
groupBy_ = groupBy;
setParameter(std::string("GroupBy"), groupBy);
}
std::vector<GetVbrFlowTopNRequest::long> GetVbrFlowTopNRequest::getAccountIds() const {
return accountIds_;
}
void GetVbrFlowTopNRequest::setAccountIds(const std::vector<GetVbrFlowTopNRequest::long> &accountIds) {
accountIds_ = accountIds;
for(int dep1 = 0; dep1 != accountIds.size(); dep1++) {
setParameter(std::string("AccountIds") + "." + std::to_string(dep1 + 1), std::to_string(accountIds[dep1]));
}
}
std::string GetVbrFlowTopNRequest::getAttachmentId() const {
return attachmentId_;
}
void GetVbrFlowTopNRequest::setAttachmentId(const std::string &attachmentId) {
attachmentId_ = attachmentId;
setParameter(std::string("AttachmentId"), attachmentId);
}

77
nis/src/model/GetVbrFlowTopNResult.cc 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.
*/
#include <alibabacloud/nis/model/GetVbrFlowTopNResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Nis;
using namespace AlibabaCloud::Nis::Model;
GetVbrFlowTopNResult::GetVbrFlowTopNResult() :
ServiceResult()
{}
GetVbrFlowTopNResult::GetVbrFlowTopNResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetVbrFlowTopNResult::~GetVbrFlowTopNResult()
{}
void GetVbrFlowTopNResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allVirtualBorderRouterFlowlogTopNNode = value["VirtualBorderRouterFlowlogTopN"]["VbrFlowlogTopN"];
for (auto valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN : allVirtualBorderRouterFlowlogTopNNode)
{
VbrFlowlogTopN virtualBorderRouterFlowlogTopNObject;
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudRegion"].isNull())
virtualBorderRouterFlowlogTopNObject.cloudRegion = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudRegion"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudIp"].isNull())
virtualBorderRouterFlowlogTopNObject.cloudIp = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudIp"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["OtherIp"].isNull())
virtualBorderRouterFlowlogTopNObject.otherIp = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["OtherIp"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudPort"].isNull())
virtualBorderRouterFlowlogTopNObject.cloudPort = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudPort"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["OtherPort"].isNull())
virtualBorderRouterFlowlogTopNObject.otherPort = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["OtherPort"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Protocol"].isNull())
virtualBorderRouterFlowlogTopNObject.protocol = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Protocol"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["AttachmentId"].isNull())
virtualBorderRouterFlowlogTopNObject.attachmentId = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["AttachmentId"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["VirtualBorderRouterId"].isNull())
virtualBorderRouterFlowlogTopNObject.virtualBorderRouterId = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["VirtualBorderRouterId"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Bytes"].isNull())
virtualBorderRouterFlowlogTopNObject.bytes = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Bytes"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Packets"].isNull())
virtualBorderRouterFlowlogTopNObject.packets = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Packets"].asString();
if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["AccountId"].isNull())
virtualBorderRouterFlowlogTopNObject.accountId = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["AccountId"].asString();
virtualBorderRouterFlowlogTopN_.push_back(virtualBorderRouterFlowlogTopNObject);
}
}
std::vector<GetVbrFlowTopNResult::VbrFlowlogTopN> GetVbrFlowTopNResult::getVirtualBorderRouterFlowlogTopN()const
{
return virtualBorderRouterFlowlogTopN_;
}