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

Generated 2021-11-11 for qianzhou.

Browse Source
This commit is contained in:
sdk-team
2024-11-22 09:45:23 +00:00
parent 055e9fa24d
commit d5a286f460
57 changed files with 3836 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.2018
1.36.2019

134
qianzhou/CMakeLists.txt Normal file
View File

@@ -0,0 +1,134 @@
#
# 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(qianzhou_public_header
include/alibabacloud/qianzhou/QianzhouClient.h
include/alibabacloud/qianzhou/QianzhouExport.h )
set(qianzhou_public_header_model
include/alibabacloud/qianzhou/model/AICreateSessionMessageRequest.h
include/alibabacloud/qianzhou/model/AICreateSessionMessageResult.h
include/alibabacloud/qianzhou/model/CreateDiagnosisRequest.h
include/alibabacloud/qianzhou/model/CreateDiagnosisResult.h
include/alibabacloud/qianzhou/model/GetClusterRequest.h
include/alibabacloud/qianzhou/model/GetClusterResult.h
include/alibabacloud/qianzhou/model/GetClusterWarningRequest.h
include/alibabacloud/qianzhou/model/GetClusterWarningResult.h
include/alibabacloud/qianzhou/model/GetDiagnosisResultRequest.h
include/alibabacloud/qianzhou/model/GetDiagnosisResultResult.h
include/alibabacloud/qianzhou/model/GetUserClusterWarningRequest.h
include/alibabacloud/qianzhou/model/GetUserClusterWarningResult.h
include/alibabacloud/qianzhou/model/GetWebshellTokenRequest.h
include/alibabacloud/qianzhou/model/GetWebshellTokenResult.h
include/alibabacloud/qianzhou/model/HelloRequest.h
include/alibabacloud/qianzhou/model/HelloResult.h
include/alibabacloud/qianzhou/model/ListClusterDeprecatedAPIRequest.h
include/alibabacloud/qianzhou/model/ListClusterDeprecatedAPIResult.h
include/alibabacloud/qianzhou/model/ListClusterImagesRequest.h
include/alibabacloud/qianzhou/model/ListClusterImagesResult.h
include/alibabacloud/qianzhou/model/ListUserClustersRequest.h
include/alibabacloud/qianzhou/model/ListUserClustersResult.h
include/alibabacloud/qianzhou/model/QueryByInstanceInfoRequest.h
include/alibabacloud/qianzhou/model/QueryByInstanceInfoResult.h
include/alibabacloud/qianzhou/model/QueryNodeInfoRequest.h
include/alibabacloud/qianzhou/model/QueryNodeInfoResult.h )
set(qianzhou_src
src/QianzhouClient.cc
src/model/AICreateSessionMessageRequest.cc
src/model/AICreateSessionMessageResult.cc
src/model/CreateDiagnosisRequest.cc
src/model/CreateDiagnosisResult.cc
src/model/GetClusterRequest.cc
src/model/GetClusterResult.cc
src/model/GetClusterWarningRequest.cc
src/model/GetClusterWarningResult.cc
src/model/GetDiagnosisResultRequest.cc
src/model/GetDiagnosisResultResult.cc
src/model/GetUserClusterWarningRequest.cc
src/model/GetUserClusterWarningResult.cc
src/model/GetWebshellTokenRequest.cc
src/model/GetWebshellTokenResult.cc
src/model/HelloRequest.cc
src/model/HelloResult.cc
src/model/ListClusterDeprecatedAPIRequest.cc
src/model/ListClusterDeprecatedAPIResult.cc
src/model/ListClusterImagesRequest.cc
src/model/ListClusterImagesResult.cc
src/model/ListUserClustersRequest.cc
src/model/ListUserClustersResult.cc
src/model/QueryByInstanceInfoRequest.cc
src/model/QueryByInstanceInfoResult.cc
src/model/QueryNodeInfoRequest.cc
src/model/QueryNodeInfoResult.cc )
add_library(qianzhou ${LIB_TYPE}
${qianzhou_public_header}
${qianzhou_public_header_model}
${qianzhou_src})
set_target_properties(qianzhou
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}qianzhou
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(qianzhou
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_QIANZHOU_LIBRARY)
endif()
target_include_directories(qianzhou
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(qianzhou
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(qianzhou
jsoncpp)
target_include_directories(qianzhou
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(qianzhou
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(qianzhou
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(qianzhou
PRIVATE /usr/include/jsoncpp)
target_link_libraries(qianzhou
jsoncpp)
endif()
install(FILES ${qianzhou_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/qianzhou)
install(FILES ${qianzhou_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/qianzhou/model)
install(TARGETS qianzhou
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

150
qianzhou/include/alibabacloud/qianzhou/QianzhouClient.h Normal file
View File

@@ -0,0 +1,150 @@
/*
* 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_QIANZHOU_QIANZHOUCLIENT_H_
#define ALIBABACLOUD_QIANZHOU_QIANZHOUCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RoaServiceClient.h>
#include "QianzhouExport.h"
#include "model/AICreateSessionMessageRequest.h"
#include "model/AICreateSessionMessageResult.h"
#include "model/CreateDiagnosisRequest.h"
#include "model/CreateDiagnosisResult.h"
#include "model/GetClusterRequest.h"
#include "model/GetClusterResult.h"
#include "model/GetClusterWarningRequest.h"
#include "model/GetClusterWarningResult.h"
#include "model/GetDiagnosisResultRequest.h"
#include "model/GetDiagnosisResultResult.h"
#include "model/GetUserClusterWarningRequest.h"
#include "model/GetUserClusterWarningResult.h"
#include "model/GetWebshellTokenRequest.h"
#include "model/GetWebshellTokenResult.h"
#include "model/HelloRequest.h"
#include "model/HelloResult.h"
#include "model/ListClusterDeprecatedAPIRequest.h"
#include "model/ListClusterDeprecatedAPIResult.h"
#include "model/ListClusterImagesRequest.h"
#include "model/ListClusterImagesResult.h"
#include "model/ListUserClustersRequest.h"
#include "model/ListUserClustersResult.h"
#include "model/QueryByInstanceInfoRequest.h"
#include "model/QueryByInstanceInfoResult.h"
#include "model/QueryNodeInfoRequest.h"
#include "model/QueryNodeInfoResult.h"
namespace AlibabaCloud
{
namespace Qianzhou
{
class ALIBABACLOUD_QIANZHOU_EXPORT QianzhouClient : public RoaServiceClient
{
public:
typedef Outcome<Error, Model::AICreateSessionMessageResult> AICreateSessionMessageOutcome;
typedef std::future<AICreateSessionMessageOutcome> AICreateSessionMessageOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::AICreateSessionMessageRequest&, const AICreateSessionMessageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AICreateSessionMessageAsyncHandler;
typedef Outcome<Error, Model::CreateDiagnosisResult> CreateDiagnosisOutcome;
typedef std::future<CreateDiagnosisOutcome> CreateDiagnosisOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::CreateDiagnosisRequest&, const CreateDiagnosisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiagnosisAsyncHandler;
typedef Outcome<Error, Model::GetClusterResult> GetClusterOutcome;
typedef std::future<GetClusterOutcome> GetClusterOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::GetClusterRequest&, const GetClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetClusterAsyncHandler;
typedef Outcome<Error, Model::GetClusterWarningResult> GetClusterWarningOutcome;
typedef std::future<GetClusterWarningOutcome> GetClusterWarningOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::GetClusterWarningRequest&, const GetClusterWarningOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetClusterWarningAsyncHandler;
typedef Outcome<Error, Model::GetDiagnosisResultResult> GetDiagnosisResultOutcome;
typedef std::future<GetDiagnosisResultOutcome> GetDiagnosisResultOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::GetDiagnosisResultRequest&, const GetDiagnosisResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDiagnosisResultAsyncHandler;
typedef Outcome<Error, Model::GetUserClusterWarningResult> GetUserClusterWarningOutcome;
typedef std::future<GetUserClusterWarningOutcome> GetUserClusterWarningOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::GetUserClusterWarningRequest&, const GetUserClusterWarningOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserClusterWarningAsyncHandler;
typedef Outcome<Error, Model::GetWebshellTokenResult> GetWebshellTokenOutcome;
typedef std::future<GetWebshellTokenOutcome> GetWebshellTokenOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::GetWebshellTokenRequest&, const GetWebshellTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWebshellTokenAsyncHandler;
typedef Outcome<Error, Model::HelloResult> HelloOutcome;
typedef std::future<HelloOutcome> HelloOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::HelloRequest&, const HelloOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HelloAsyncHandler;
typedef Outcome<Error, Model::ListClusterDeprecatedAPIResult> ListClusterDeprecatedAPIOutcome;
typedef std::future<ListClusterDeprecatedAPIOutcome> ListClusterDeprecatedAPIOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::ListClusterDeprecatedAPIRequest&, const ListClusterDeprecatedAPIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterDeprecatedAPIAsyncHandler;
typedef Outcome<Error, Model::ListClusterImagesResult> ListClusterImagesOutcome;
typedef std::future<ListClusterImagesOutcome> ListClusterImagesOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::ListClusterImagesRequest&, const ListClusterImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterImagesAsyncHandler;
typedef Outcome<Error, Model::ListUserClustersResult> ListUserClustersOutcome;
typedef std::future<ListUserClustersOutcome> ListUserClustersOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::ListUserClustersRequest&, const ListUserClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserClustersAsyncHandler;
typedef Outcome<Error, Model::QueryByInstanceInfoResult> QueryByInstanceInfoOutcome;
typedef std::future<QueryByInstanceInfoOutcome> QueryByInstanceInfoOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::QueryByInstanceInfoRequest&, const QueryByInstanceInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryByInstanceInfoAsyncHandler;
typedef Outcome<Error, Model::QueryNodeInfoResult> QueryNodeInfoOutcome;
typedef std::future<QueryNodeInfoOutcome> QueryNodeInfoOutcomeCallable;
typedef std::function<void(const QianzhouClient*, const Model::QueryNodeInfoRequest&, const QueryNodeInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryNodeInfoAsyncHandler;
QianzhouClient(const Credentials &credentials, const ClientConfiguration &configuration);
QianzhouClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
QianzhouClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~QianzhouClient();
AICreateSessionMessageOutcome aICreateSessionMessage(const Model::AICreateSessionMessageRequest &request)const;
void aICreateSessionMessageAsync(const Model::AICreateSessionMessageRequest& request, const AICreateSessionMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AICreateSessionMessageOutcomeCallable aICreateSessionMessageCallable(const Model::AICreateSessionMessageRequest& request) const;
CreateDiagnosisOutcome createDiagnosis(const Model::CreateDiagnosisRequest &request)const;
void createDiagnosisAsync(const Model::CreateDiagnosisRequest& request, const CreateDiagnosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDiagnosisOutcomeCallable createDiagnosisCallable(const Model::CreateDiagnosisRequest& request) const;
GetClusterOutcome getCluster(const Model::GetClusterRequest &request)const;
void getClusterAsync(const Model::GetClusterRequest& request, const GetClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetClusterOutcomeCallable getClusterCallable(const Model::GetClusterRequest& request) const;
GetClusterWarningOutcome getClusterWarning(const Model::GetClusterWarningRequest &request)const;
void getClusterWarningAsync(const Model::GetClusterWarningRequest& request, const GetClusterWarningAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetClusterWarningOutcomeCallable getClusterWarningCallable(const Model::GetClusterWarningRequest& request) const;
GetDiagnosisResultOutcome getDiagnosisResult(const Model::GetDiagnosisResultRequest &request)const;
void getDiagnosisResultAsync(const Model::GetDiagnosisResultRequest& request, const GetDiagnosisResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetDiagnosisResultOutcomeCallable getDiagnosisResultCallable(const Model::GetDiagnosisResultRequest& request) const;
GetUserClusterWarningOutcome getUserClusterWarning(const Model::GetUserClusterWarningRequest &request)const;
void getUserClusterWarningAsync(const Model::GetUserClusterWarningRequest& request, const GetUserClusterWarningAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetUserClusterWarningOutcomeCallable getUserClusterWarningCallable(const Model::GetUserClusterWarningRequest& request) const;
GetWebshellTokenOutcome getWebshellToken(const Model::GetWebshellTokenRequest &request)const;
void getWebshellTokenAsync(const Model::GetWebshellTokenRequest& request, const GetWebshellTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetWebshellTokenOutcomeCallable getWebshellTokenCallable(const Model::GetWebshellTokenRequest& request) const;
HelloOutcome hello(const Model::HelloRequest &request)const;
void helloAsync(const Model::HelloRequest& request, const HelloAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HelloOutcomeCallable helloCallable(const Model::HelloRequest& request) const;
ListClusterDeprecatedAPIOutcome listClusterDeprecatedAPI(const Model::ListClusterDeprecatedAPIRequest &request)const;
void listClusterDeprecatedAPIAsync(const Model::ListClusterDeprecatedAPIRequest& request, const ListClusterDeprecatedAPIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListClusterDeprecatedAPIOutcomeCallable listClusterDeprecatedAPICallable(const Model::ListClusterDeprecatedAPIRequest& request) const;
ListClusterImagesOutcome listClusterImages(const Model::ListClusterImagesRequest &request)const;
void listClusterImagesAsync(const Model::ListClusterImagesRequest& request, const ListClusterImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListClusterImagesOutcomeCallable listClusterImagesCallable(const Model::ListClusterImagesRequest& request) const;
ListUserClustersOutcome listUserClusters(const Model::ListUserClustersRequest &request)const;
void listUserClustersAsync(const Model::ListUserClustersRequest& request, const ListUserClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListUserClustersOutcomeCallable listUserClustersCallable(const Model::ListUserClustersRequest& request) const;
QueryByInstanceInfoOutcome queryByInstanceInfo(const Model::QueryByInstanceInfoRequest &request)const;
void queryByInstanceInfoAsync(const Model::QueryByInstanceInfoRequest& request, const QueryByInstanceInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryByInstanceInfoOutcomeCallable queryByInstanceInfoCallable(const Model::QueryByInstanceInfoRequest& request) const;
QueryNodeInfoOutcome queryNodeInfo(const Model::QueryNodeInfoRequest &request)const;
void queryNodeInfoAsync(const Model::QueryNodeInfoRequest& request, const QueryNodeInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryNodeInfoOutcomeCallable queryNodeInfoCallable(const Model::QueryNodeInfoRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_QIANZHOU_QIANZHOUCLIENT_H_

32
qianzhou/include/alibabacloud/qianzhou/QianzhouExport.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_QIANZHOU_QIANZHOUEXPORT_H_
#define ALIBABACLOUD_QIANZHOU_QIANZHOUEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_QIANZHOU_LIBRARY)
# define ALIBABACLOUD_QIANZHOU_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_QIANZHOU_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_QIANZHOU_EXPORT
#endif
#endif // !ALIBABACLOUD_QIANZHOU_QIANZHOUEXPORT_H_

60
qianzhou/include/alibabacloud/qianzhou/model/AICreateSessionMessageRequest.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_QIANZHOU_MODEL_AICREATESESSIONMESSAGEREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_AICREATESESSIONMESSAGEREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT AICreateSessionMessageRequest : public RoaServiceRequest {
public:
struct Body {
struct Context {
std::string cluster_id;
std::string kind;
std::string _namespace;
std::string name;
std::string error;
std::string uuid;
};
context context;
std::string session_id;
std::string language;
std::string type;
std::string message;
};
AICreateSessionMessageRequest();
~AICreateSessionMessageRequest();
std::string getEmployee_id() const;
void setEmployee_id(const std::string &employee_id);
body getBody() const;
void setBody(const body &body);
private:
std::string employee_id_;
body body_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_AICREATESESSIONMESSAGEREQUEST_H_

61
qianzhou/include/alibabacloud/qianzhou/model/AICreateSessionMessageResult.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_QIANZHOU_MODEL_AICREATESESSIONMESSAGERESULT_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_AICREATESESSIONMESSAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/qianzhou/QianzhouExport.h>
namespace AlibabaCloud
{
namespace Qianzhou
{
namespace Model
{
class ALIBABACLOUD_QIANZHOU_EXPORT AICreateSessionMessageResult : public ServiceResult
{
public:
AICreateSessionMessageResult();
explicit AICreateSessionMessageResult(const std::string &payload);
~AICreateSessionMessageResult();
std::string getMsg()const;
std::string getAnswer()const;
std::string getRequestId()const;
std::string getData()const;
std::string getSession_id()const;
long getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string msg_;
std::string answer_;
std::string requestId_;
std::string data_;
std::string session_id_;
long code_;
};
}
}
}
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_AICREATESESSIONMESSAGERESULT_H_

48
qianzhou/include/alibabacloud/qianzhou/model/CreateDiagnosisRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_QIANZHOU_MODEL_CREATEDIAGNOSISREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_CREATEDIAGNOSISREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT CreateDiagnosisRequest : public RoaServiceRequest {
public:
CreateDiagnosisRequest();
~CreateDiagnosisRequest();
std::string getDiagnosisType() const;
void setDiagnosisType(const std::string &diagnosisType);
std::string getClusterID() const;
void setClusterID(const std::string &clusterID);
std::string getBody() const;
void setBody(const std::string &body);
private:
std::string diagnosisType_;
std::string clusterID_;
std::string body_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_CREATEDIAGNOSISREQUEST_H_

55
qianzhou/include/alibabacloud/qianzhou/model/CreateDiagnosisResult.h Normal file
View File

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

42
qianzhou/include/alibabacloud/qianzhou/model/GetClusterRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_QIANZHOU_MODEL_GETCLUSTERREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_GETCLUSTERREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT GetClusterRequest : public RoaServiceRequest {
public:
GetClusterRequest();
~GetClusterRequest();
std::string getClusterID() const;
void setClusterID(const std::string &clusterID);
private:
std::string clusterID_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_GETCLUSTERREQUEST_H_

66
qianzhou/include/alibabacloud/qianzhou/model/GetClusterResult.h Normal file
View File

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

42
qianzhou/include/alibabacloud/qianzhou/model/GetClusterWarningRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_QIANZHOU_MODEL_GETCLUSTERWARNINGREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_GETCLUSTERWARNINGREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT GetClusterWarningRequest : public RoaServiceRequest {
public:
GetClusterWarningRequest();
~GetClusterWarningRequest();
std::string getClusterID() const;
void setClusterID(const std::string &clusterID);
private:
std::string clusterID_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_GETCLUSTERWARNINGREQUEST_H_

51
qianzhou/include/alibabacloud/qianzhou/model/GetClusterWarningResult.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_QIANZHOU_MODEL_GETCLUSTERWARNINGRESULT_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_GETCLUSTERWARNINGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/qianzhou/QianzhouExport.h>
namespace AlibabaCloud
{
namespace Qianzhou
{
namespace Model
{
class ALIBABACLOUD_QIANZHOU_EXPORT GetClusterWarningResult : public ServiceResult
{
public:
GetClusterWarningResult();
explicit GetClusterWarningResult(const std::string &payload);
~GetClusterWarningResult();
std::string getRequestId()const;
protected:
void parse(const std::string &payload);
private:
std::string requestId_;
};
}
}
}
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_GETCLUSTERWARNINGRESULT_H_

45
qianzhou/include/alibabacloud/qianzhou/model/GetDiagnosisResultRequest.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_QIANZHOU_MODEL_GETDIAGNOSISRESULTREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_GETDIAGNOSISRESULTREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT GetDiagnosisResultRequest : public RoaServiceRequest {
public:
GetDiagnosisResultRequest();
~GetDiagnosisResultRequest();
std::string getDiagnosisId() const;
void setDiagnosisId(const std::string &diagnosisId);
std::string getOwnerUid() const;
void setOwnerUid(const std::string &ownerUid);
private:
std::string diagnosisId_;
std::string ownerUid_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_GETDIAGNOSISRESULTREQUEST_H_

57
qianzhou/include/alibabacloud/qianzhou/model/GetDiagnosisResultResult.h Normal file
View File

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

42
qianzhou/include/alibabacloud/qianzhou/model/GetUserClusterWarningRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_QIANZHOU_MODEL_GETUSERCLUSTERWARNINGREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_GETUSERCLUSTERWARNINGREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT GetUserClusterWarningRequest : public RoaServiceRequest {
public:
GetUserClusterWarningRequest();
~GetUserClusterWarningRequest();
std::string getUserID() const;
void setUserID(const std::string &userID);
private:
std::string userID_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_GETUSERCLUSTERWARNINGREQUEST_H_

51
qianzhou/include/alibabacloud/qianzhou/model/GetUserClusterWarningResult.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_QIANZHOU_MODEL_GETUSERCLUSTERWARNINGRESULT_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_GETUSERCLUSTERWARNINGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/qianzhou/QianzhouExport.h>
namespace AlibabaCloud
{
namespace Qianzhou
{
namespace Model
{
class ALIBABACLOUD_QIANZHOU_EXPORT GetUserClusterWarningResult : public ServiceResult
{
public:
GetUserClusterWarningResult();
explicit GetUserClusterWarningResult(const std::string &payload);
~GetUserClusterWarningResult();
std::string getRequestId()const;
protected:
void parse(const std::string &payload);
private:
std::string requestId_;
};
}
}
}
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_GETUSERCLUSTERWARNINGRESULT_H_

39
qianzhou/include/alibabacloud/qianzhou/model/GetWebshellTokenRequest.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* 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_QIANZHOU_MODEL_GETWEBSHELLTOKENREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_GETWEBSHELLTOKENREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT GetWebshellTokenRequest : public RoaServiceRequest {
public:
GetWebshellTokenRequest();
~GetWebshellTokenRequest();
private:
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_GETWEBSHELLTOKENREQUEST_H_

51
qianzhou/include/alibabacloud/qianzhou/model/GetWebshellTokenResult.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_QIANZHOU_MODEL_GETWEBSHELLTOKENRESULT_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_GETWEBSHELLTOKENRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/qianzhou/QianzhouExport.h>
namespace AlibabaCloud
{
namespace Qianzhou
{
namespace Model
{
class ALIBABACLOUD_QIANZHOU_EXPORT GetWebshellTokenResult : public ServiceResult
{
public:
GetWebshellTokenResult();
explicit GetWebshellTokenResult(const std::string &payload);
~GetWebshellTokenResult();
std::string getRequestId()const;
protected:
void parse(const std::string &payload);
private:
std::string requestId_;
};
}
}
}
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_GETWEBSHELLTOKENRESULT_H_

42
qianzhou/include/alibabacloud/qianzhou/model/HelloRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_QIANZHOU_MODEL_HELLOREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_HELLOREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT HelloRequest : public RoaServiceRequest {
public:
HelloRequest();
~HelloRequest();
std::string getUser() const;
void setUser(const std::string &user);
private:
std::string user_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_HELLOREQUEST_H_

63
qianzhou/include/alibabacloud/qianzhou/model/HelloResult.h Normal file
View File

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

51
qianzhou/include/alibabacloud/qianzhou/model/ListClusterDeprecatedAPIRequest.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_QIANZHOU_MODEL_LISTCLUSTERDEPRECATEDAPIREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERDEPRECATEDAPIREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT ListClusterDeprecatedAPIRequest : public RoaServiceRequest {
public:
ListClusterDeprecatedAPIRequest();
~ListClusterDeprecatedAPIRequest();
std::string getCluster_id() const;
void setCluster_id(const std::string &cluster_id);
int getPage_no() const;
void setPage_no(int page_no);
std::string getTarget_version() const;
void setTarget_version(const std::string &target_version);
int getPage_size() const;
void setPage_size(int page_size);
private:
std::string cluster_id_;
int page_no_;
std::string target_version_;
int page_size_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERDEPRECATEDAPIREQUEST_H_

79
qianzhou/include/alibabacloud/qianzhou/model/ListClusterDeprecatedAPIResult.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_QIANZHOU_MODEL_LISTCLUSTERDEPRECATEDAPIRESULT_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERDEPRECATEDAPIRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/qianzhou/QianzhouExport.h>
namespace AlibabaCloud
{
namespace Qianzhou
{
namespace Model
{
class ALIBABACLOUD_QIANZHOU_EXPORT ListClusterDeprecatedAPIResult : public ServiceResult
{
public:
struct Datas
{
struct DataItem
{
std::string user_agent;
std::string target_version;
std::string deprecated_k8s_version;
std::string cluster_id;
std::string last_time;
std::string content;
std::string request_uri;
std::string label;
int count;
std::string current_version;
std::string source_ips;
std::string ds;
};
std::vector<DataItem> data;
int pageSize;
int total;
int current;
};
ListClusterDeprecatedAPIResult();
explicit ListClusterDeprecatedAPIResult(const std::string &payload);
~ListClusterDeprecatedAPIResult();
std::string getMsg()const;
std::string getRequestId()const;
Datas getDatas()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string msg_;
std::string requestId_;
Datas datas_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERDEPRECATEDAPIRESULT_H_

57
qianzhou/include/alibabacloud/qianzhou/model/ListClusterImagesRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERIMAGESREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERIMAGESREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT ListClusterImagesRequest : public RoaServiceRequest {
public:
ListClusterImagesRequest();
~ListClusterImagesRequest();
std::string getImage_name() const;
void setImage_name(const std::string &image_name);
std::string getUid() const;
void setUid(const std::string &uid);
std::string getCluster_id() const;
void setCluster_id(const std::string &cluster_id);
std::string getImage_hash() const;
void setImage_hash(const std::string &image_hash);
int getPage_no() const;
void setPage_no(int page_no);
int getPage_size() const;
void setPage_size(int page_size);
private:
std::string image_name_;
std::string uid_;
std::string cluster_id_;
std::string image_hash_;
int page_no_;
int page_size_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERIMAGESREQUEST_H_

76
qianzhou/include/alibabacloud/qianzhou/model/ListClusterImagesResult.h Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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_QIANZHOU_MODEL_LISTCLUSTERIMAGESRESULT_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERIMAGESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/qianzhou/QianzhouExport.h>
namespace AlibabaCloud
{
namespace Qianzhou
{
namespace Model
{
class ALIBABACLOUD_QIANZHOU_EXPORT ListClusterImagesResult : public ServiceResult
{
public:
struct Datas
{
struct DataItem
{
std::string uid;
std::string controller_type;
std::string controller_name;
std::string cluster_id;
std::string updated;
std::string _namespace;
std::string image_name;
std::string image_hash;
std::string created;
};
std::vector<DataItem> data;
int pageSize;
int total;
int current;
};
ListClusterImagesResult();
explicit ListClusterImagesResult(const std::string &payload);
~ListClusterImagesResult();
std::string getMsg()const;
std::string getRequestId()const;
Datas getDatas()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string msg_;
std::string requestId_;
Datas datas_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_LISTCLUSTERIMAGESRESULT_H_

48
qianzhou/include/alibabacloud/qianzhou/model/ListUserClustersRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_QIANZHOU_MODEL_LISTUSERCLUSTERSREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_LISTUSERCLUSTERSREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT ListUserClustersRequest : public RoaServiceRequest {
public:
ListUserClustersRequest();
~ListUserClustersRequest();
std::string getCurrent() const;
void setCurrent(const std::string &current);
std::string getPageSize() const;
void setPageSize(const std::string &pageSize);
std::string getUserID() const;
void setUserID(const std::string &userID);
private:
std::string current_;
std::string pageSize_;
std::string userID_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_LISTUSERCLUSTERSREQUEST_H_

57
qianzhou/include/alibabacloud/qianzhou/model/ListUserClustersResult.h Normal file
View File

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

42
qianzhou/include/alibabacloud/qianzhou/model/QueryByInstanceInfoRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_QIANZHOU_MODEL_QUERYBYINSTANCEINFOREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_QUERYBYINSTANCEINFOREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT QueryByInstanceInfoRequest : public RoaServiceRequest {
public:
QueryByInstanceInfoRequest();
~QueryByInstanceInfoRequest();
std::string getBody() const;
void setBody(const std::string &body);
private:
std::string body_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_QUERYBYINSTANCEINFOREQUEST_H_

65
qianzhou/include/alibabacloud/qianzhou/model/QueryByInstanceInfoResult.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_QIANZHOU_MODEL_QUERYBYINSTANCEINFORESULT_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_QUERYBYINSTANCEINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/qianzhou/QianzhouExport.h>
namespace AlibabaCloud
{
namespace Qianzhou
{
namespace Model
{
class ALIBABACLOUD_QIANZHOU_EXPORT QueryByInstanceInfoResult : public ServiceResult
{
public:
struct DataItem
{
std::string uid;
std::string clusterId;
std::string instanceId;
std::string clusterName;
std::string regionId;
};
QueryByInstanceInfoResult();
explicit QueryByInstanceInfoResult(const std::string &payload);
~QueryByInstanceInfoResult();
std::string getMsg()const;
std::vector<DataItem> getdata()const;
std::string getRequestId()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string msg_;
std::vector<DataItem> data_;
std::string requestId_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_QUERYBYINSTANCEINFORESULT_H_

45
qianzhou/include/alibabacloud/qianzhou/model/QueryNodeInfoRequest.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_QIANZHOU_MODEL_QUERYNODEINFOREQUEST_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_QUERYNODEINFOREQUEST_H_
#include <alibabacloud/qianzhou/QianzhouExport.h>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Qianzhou {
namespace Model {
class ALIBABACLOUD_QIANZHOU_EXPORT QueryNodeInfoRequest : public RoaServiceRequest {
public:
QueryNodeInfoRequest();
~QueryNodeInfoRequest();
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string instanceId_;
std::string regionId_;
};
} // namespace Model
} // namespace Qianzhou
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_QUERYNODEINFOREQUEST_H_

65
qianzhou/include/alibabacloud/qianzhou/model/QueryNodeInfoResult.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_QIANZHOU_MODEL_QUERYNODEINFORESULT_H_
#define ALIBABACLOUD_QIANZHOU_MODEL_QUERYNODEINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/qianzhou/QianzhouExport.h>
namespace AlibabaCloud
{
namespace Qianzhou
{
namespace Model
{
class ALIBABACLOUD_QIANZHOU_EXPORT QueryNodeInfoResult : public ServiceResult
{
public:
struct DataItem
{
std::string uid;
std::string clusterId;
std::string instanceId;
std::string region;
std::string cluserName;
};
QueryNodeInfoResult();
explicit QueryNodeInfoResult(const std::string &payload);
~QueryNodeInfoResult();
std::string getMsg()const;
std::vector<DataItem> getdata()const;
std::string getRequestId()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string msg_;
std::vector<DataItem> data_;
std::string requestId_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_QIANZHOU_MODEL_QUERYNODEINFORESULT_H_

521
qianzhou/src/QianzhouClient.cc Normal file
View File

@@ -0,0 +1,521 @@
/*
* 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/qianzhou/QianzhouClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
namespace
{
const std::string SERVICE_NAME = "qianzhou";
}
QianzhouClient::QianzhouClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RoaServiceClient(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, "");
}
QianzhouClient::QianzhouClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RoaServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
QianzhouClient::QianzhouClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RoaServiceClient(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, "");
}
QianzhouClient::~QianzhouClient()
{}
QianzhouClient::AICreateSessionMessageOutcome QianzhouClient::aICreateSessionMessage(const AICreateSessionMessageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AICreateSessionMessageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AICreateSessionMessageOutcome(AICreateSessionMessageResult(outcome.result()));
else
return AICreateSessionMessageOutcome(outcome.error());
}
void QianzhouClient::aICreateSessionMessageAsync(const AICreateSessionMessageRequest& request, const AICreateSessionMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, aICreateSessionMessage(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::AICreateSessionMessageOutcomeCallable QianzhouClient::aICreateSessionMessageCallable(const AICreateSessionMessageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AICreateSessionMessageOutcome()>>(
[this, request]()
{
return this->aICreateSessionMessage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::CreateDiagnosisOutcome QianzhouClient::createDiagnosis(const CreateDiagnosisRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDiagnosisOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDiagnosisOutcome(CreateDiagnosisResult(outcome.result()));
else
return CreateDiagnosisOutcome(outcome.error());
}
void QianzhouClient::createDiagnosisAsync(const CreateDiagnosisRequest& request, const CreateDiagnosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDiagnosis(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::CreateDiagnosisOutcomeCallable QianzhouClient::createDiagnosisCallable(const CreateDiagnosisRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDiagnosisOutcome()>>(
[this, request]()
{
return this->createDiagnosis(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::GetClusterOutcome QianzhouClient::getCluster(const GetClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetClusterOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetClusterOutcome(GetClusterResult(outcome.result()));
else
return GetClusterOutcome(outcome.error());
}
void QianzhouClient::getClusterAsync(const GetClusterRequest& request, const GetClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getCluster(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::GetClusterOutcomeCallable QianzhouClient::getClusterCallable(const GetClusterRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetClusterOutcome()>>(
[this, request]()
{
return this->getCluster(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::GetClusterWarningOutcome QianzhouClient::getClusterWarning(const GetClusterWarningRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetClusterWarningOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetClusterWarningOutcome(GetClusterWarningResult(outcome.result()));
else
return GetClusterWarningOutcome(outcome.error());
}
void QianzhouClient::getClusterWarningAsync(const GetClusterWarningRequest& request, const GetClusterWarningAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getClusterWarning(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::GetClusterWarningOutcomeCallable QianzhouClient::getClusterWarningCallable(const GetClusterWarningRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetClusterWarningOutcome()>>(
[this, request]()
{
return this->getClusterWarning(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::GetDiagnosisResultOutcome QianzhouClient::getDiagnosisResult(const GetDiagnosisResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetDiagnosisResultOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetDiagnosisResultOutcome(GetDiagnosisResultResult(outcome.result()));
else
return GetDiagnosisResultOutcome(outcome.error());
}
void QianzhouClient::getDiagnosisResultAsync(const GetDiagnosisResultRequest& request, const GetDiagnosisResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getDiagnosisResult(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::GetDiagnosisResultOutcomeCallable QianzhouClient::getDiagnosisResultCallable(const GetDiagnosisResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetDiagnosisResultOutcome()>>(
[this, request]()
{
return this->getDiagnosisResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::GetUserClusterWarningOutcome QianzhouClient::getUserClusterWarning(const GetUserClusterWarningRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetUserClusterWarningOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetUserClusterWarningOutcome(GetUserClusterWarningResult(outcome.result()));
else
return GetUserClusterWarningOutcome(outcome.error());
}
void QianzhouClient::getUserClusterWarningAsync(const GetUserClusterWarningRequest& request, const GetUserClusterWarningAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getUserClusterWarning(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::GetUserClusterWarningOutcomeCallable QianzhouClient::getUserClusterWarningCallable(const GetUserClusterWarningRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetUserClusterWarningOutcome()>>(
[this, request]()
{
return this->getUserClusterWarning(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::GetWebshellTokenOutcome QianzhouClient::getWebshellToken(const GetWebshellTokenRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetWebshellTokenOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetWebshellTokenOutcome(GetWebshellTokenResult(outcome.result()));
else
return GetWebshellTokenOutcome(outcome.error());
}
void QianzhouClient::getWebshellTokenAsync(const GetWebshellTokenRequest& request, const GetWebshellTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getWebshellToken(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::GetWebshellTokenOutcomeCallable QianzhouClient::getWebshellTokenCallable(const GetWebshellTokenRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetWebshellTokenOutcome()>>(
[this, request]()
{
return this->getWebshellToken(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::HelloOutcome QianzhouClient::hello(const HelloRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HelloOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HelloOutcome(HelloResult(outcome.result()));
else
return HelloOutcome(outcome.error());
}
void QianzhouClient::helloAsync(const HelloRequest& request, const HelloAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, hello(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::HelloOutcomeCallable QianzhouClient::helloCallable(const HelloRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HelloOutcome()>>(
[this, request]()
{
return this->hello(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::ListClusterDeprecatedAPIOutcome QianzhouClient::listClusterDeprecatedAPI(const ListClusterDeprecatedAPIRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListClusterDeprecatedAPIOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListClusterDeprecatedAPIOutcome(ListClusterDeprecatedAPIResult(outcome.result()));
else
return ListClusterDeprecatedAPIOutcome(outcome.error());
}
void QianzhouClient::listClusterDeprecatedAPIAsync(const ListClusterDeprecatedAPIRequest& request, const ListClusterDeprecatedAPIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listClusterDeprecatedAPI(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::ListClusterDeprecatedAPIOutcomeCallable QianzhouClient::listClusterDeprecatedAPICallable(const ListClusterDeprecatedAPIRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListClusterDeprecatedAPIOutcome()>>(
[this, request]()
{
return this->listClusterDeprecatedAPI(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::ListClusterImagesOutcome QianzhouClient::listClusterImages(const ListClusterImagesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListClusterImagesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListClusterImagesOutcome(ListClusterImagesResult(outcome.result()));
else
return ListClusterImagesOutcome(outcome.error());
}
void QianzhouClient::listClusterImagesAsync(const ListClusterImagesRequest& request, const ListClusterImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listClusterImages(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::ListClusterImagesOutcomeCallable QianzhouClient::listClusterImagesCallable(const ListClusterImagesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListClusterImagesOutcome()>>(
[this, request]()
{
return this->listClusterImages(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::ListUserClustersOutcome QianzhouClient::listUserClusters(const ListUserClustersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListUserClustersOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListUserClustersOutcome(ListUserClustersResult(outcome.result()));
else
return ListUserClustersOutcome(outcome.error());
}
void QianzhouClient::listUserClustersAsync(const ListUserClustersRequest& request, const ListUserClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listUserClusters(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::ListUserClustersOutcomeCallable QianzhouClient::listUserClustersCallable(const ListUserClustersRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListUserClustersOutcome()>>(
[this, request]()
{
return this->listUserClusters(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::QueryByInstanceInfoOutcome QianzhouClient::queryByInstanceInfo(const QueryByInstanceInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryByInstanceInfoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryByInstanceInfoOutcome(QueryByInstanceInfoResult(outcome.result()));
else
return QueryByInstanceInfoOutcome(outcome.error());
}
void QianzhouClient::queryByInstanceInfoAsync(const QueryByInstanceInfoRequest& request, const QueryByInstanceInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryByInstanceInfo(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::QueryByInstanceInfoOutcomeCallable QianzhouClient::queryByInstanceInfoCallable(const QueryByInstanceInfoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryByInstanceInfoOutcome()>>(
[this, request]()
{
return this->queryByInstanceInfo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
QianzhouClient::QueryNodeInfoOutcome QianzhouClient::queryNodeInfo(const QueryNodeInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryNodeInfoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryNodeInfoOutcome(QueryNodeInfoResult(outcome.result()));
else
return QueryNodeInfoOutcome(outcome.error());
}
void QianzhouClient::queryNodeInfoAsync(const QueryNodeInfoRequest& request, const QueryNodeInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryNodeInfo(request), context);
};
asyncExecute(new Runnable(fn));
}
QianzhouClient::QueryNodeInfoOutcomeCallable QianzhouClient::queryNodeInfoCallable(const QueryNodeInfoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryNodeInfoOutcome()>>(
[this, request]()
{
return this->queryNodeInfo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

55
qianzhou/src/model/AICreateSessionMessageRequest.cc Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/qianzhou/model/AICreateSessionMessageRequest.h>
using AlibabaCloud::Qianzhou::Model::AICreateSessionMessageRequest;
AICreateSessionMessageRequest::AICreateSessionMessageRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/AICreateSessionMessage"};
setMethod(HttpRequest::Method::Post);
}
AICreateSessionMessageRequest::~AICreateSessionMessageRequest() {}
std::string AICreateSessionMessageRequest::getEmployee_id() const {
return employee_id_;
}
void AICreateSessionMessageRequest::setEmployee_id(const std::string &employee_id) {
employee_id_ = employee_id;
setParameter(std::string("employee_id"), employee_id);
}
AICreateSessionMessageRequest::body AICreateSessionMessageRequest::getBody() const {
return body_;
}
void AICreateSessionMessageRequest::setBody(const AICreateSessionMessageRequest::body &body) {
body_ = body;
setBodyParameter(std::string("body") + ".context.cluster_id", body.context.cluster_id);
setBodyParameter(std::string("body") + ".context.kind", body.context.kind);
setBodyParameter(std::string("body") + ".context.namespace", body.context._namespace);
setBodyParameter(std::string("body") + ".context.name", body.context.name);
setBodyParameter(std::string("body") + ".context.error", body.context.error);
setBodyParameter(std::string("body") + ".context.uuid", body.context.uuid);
setBodyParameter(std::string("body") + ".session_id", body.session_id);
setBodyParameter(std::string("body") + ".language", body.language);
setBodyParameter(std::string("body") + ".type", body.type);
setBodyParameter(std::string("body") + ".message", body.message);
}

86
qianzhou/src/model/AICreateSessionMessageResult.cc Normal file
View File

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

55
qianzhou/src/model/CreateDiagnosisRequest.cc Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/qianzhou/model/CreateDiagnosisRequest.h>
using AlibabaCloud::Qianzhou::Model::CreateDiagnosisRequest;
CreateDiagnosisRequest::CreateDiagnosisRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/createDiagnosis"};
setMethod(HttpRequest::Method::Post);
}
CreateDiagnosisRequest::~CreateDiagnosisRequest() {}
std::string CreateDiagnosisRequest::getDiagnosisType() const {
return diagnosisType_;
}
void CreateDiagnosisRequest::setDiagnosisType(const std::string &diagnosisType) {
diagnosisType_ = diagnosisType;
setParameter(std::string("diagnosisType"), diagnosisType);
}
std::string CreateDiagnosisRequest::getClusterID() const {
return clusterID_;
}
void CreateDiagnosisRequest::setClusterID(const std::string &clusterID) {
clusterID_ = clusterID;
setParameter(std::string("clusterID"), clusterID);
}
std::string CreateDiagnosisRequest::getBody() const {
return body_;
}
void CreateDiagnosisRequest::setBody(const std::string &body) {
body_ = body;
setBodyParameter(std::string("body"), body);
}

65
qianzhou/src/model/CreateDiagnosisResult.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/qianzhou/model/CreateDiagnosisResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
CreateDiagnosisResult::CreateDiagnosisResult() :
ServiceResult()
{}
CreateDiagnosisResult::CreateDiagnosisResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDiagnosisResult::~CreateDiagnosisResult()
{}
void CreateDiagnosisResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
if(!value["code"].isNull())
code_ = std::stol(value["code"].asString());
if(!value["data"].isNull())
data_ = value["data"].asString();
}
std::string CreateDiagnosisResult::getRequestId()const
{
return requestId_;
}
ObjectOfAny CreateDiagnosisResult::getData()const
{
return data_;
}
long CreateDiagnosisResult::getCode()const
{
return code_;
}

37
qianzhou/src/model/GetClusterRequest.cc Normal file
View File

@@ -0,0 +1,37 @@
/*
* 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/qianzhou/model/GetClusterRequest.h>
using AlibabaCloud::Qianzhou::Model::GetClusterRequest;
GetClusterRequest::GetClusterRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/getCluster"};
setMethod(HttpRequest::Method::Get);
}
GetClusterRequest::~GetClusterRequest() {}
std::string GetClusterRequest::getClusterID() const {
return clusterID_;
}
void GetClusterRequest::setClusterID(const std::string &clusterID) {
clusterID_ = clusterID;
setParameter(std::string("clusterID"), clusterID);
}

77
qianzhou/src/model/GetClusterResult.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/qianzhou/model/GetClusterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
GetClusterResult::GetClusterResult() :
ServiceResult()
{}
GetClusterResult::GetClusterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetClusterResult::~GetClusterResult()
{}
void GetClusterResult::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["clusterID"].isNull())
data_.clusterID = dataNode["clusterID"].asString();
if(!dataNode["name"].isNull())
data_.name = dataNode["name"].asString();
if(!dataNode["regionID"].isNull())
data_.regionID = dataNode["regionID"].asString();
if(!dataNode["state"].isNull())
data_.state = dataNode["state"].asString();
if(!dataNode["userID"].isNull())
data_.userID = dataNode["userID"].asString();
if(!dataNode["clusterType"].isNull())
data_.clusterType = dataNode["clusterType"].asString();
if(!dataNode["currentVersion"].isNull())
data_.currentVersion = dataNode["currentVersion"].asString();
if(!dataNode["securityGroupId"].isNull())
data_.securityGroupId = dataNode["securityGroupId"].asString();
if(!dataNode["profile"].isNull())
data_.profile = dataNode["profile"].asString();
if(!dataNode["spec"].isNull())
data_.spec = dataNode["spec"].asString();
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
}
std::string GetClusterResult::getRequestId()const
{
return requestId_;
}
GetClusterResult::Data GetClusterResult::getData()const
{
return data_;
}

37
qianzhou/src/model/GetClusterWarningRequest.cc Normal file
View File

@@ -0,0 +1,37 @@
/*
* 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/qianzhou/model/GetClusterWarningRequest.h>
using AlibabaCloud::Qianzhou::Model::GetClusterWarningRequest;
GetClusterWarningRequest::GetClusterWarningRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/getKeyClusterWarningList"};
setMethod(HttpRequest::Method::Get);
}
GetClusterWarningRequest::~GetClusterWarningRequest() {}
std::string GetClusterWarningRequest::getClusterID() const {
return clusterID_;
}
void GetClusterWarningRequest::setClusterID(const std::string &clusterID) {
clusterID_ = clusterID;
setParameter(std::string("clusterID"), clusterID);
}

51
qianzhou/src/model/GetClusterWarningResult.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/qianzhou/model/GetClusterWarningResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
GetClusterWarningResult::GetClusterWarningResult() :
ServiceResult()
{}
GetClusterWarningResult::GetClusterWarningResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetClusterWarningResult::~GetClusterWarningResult()
{}
void GetClusterWarningResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
}
std::string GetClusterWarningResult::getRequestId()const
{
return requestId_;
}

46
qianzhou/src/model/GetDiagnosisResultRequest.cc Normal file
View File

@@ -0,0 +1,46 @@
/*
* 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/qianzhou/model/GetDiagnosisResultRequest.h>
using AlibabaCloud::Qianzhou::Model::GetDiagnosisResultRequest;
GetDiagnosisResultRequest::GetDiagnosisResultRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/GetDiagnosisResult"};
setMethod(HttpRequest::Method::Get);
}
GetDiagnosisResultRequest::~GetDiagnosisResultRequest() {}
std::string GetDiagnosisResultRequest::getDiagnosisId() const {
return diagnosisId_;
}
void GetDiagnosisResultRequest::setDiagnosisId(const std::string &diagnosisId) {
diagnosisId_ = diagnosisId;
setParameter(std::string("diagnosisId"), diagnosisId);
}
std::string GetDiagnosisResultRequest::getOwnerUid() const {
return ownerUid_;
}
void GetDiagnosisResultRequest::setOwnerUid(const std::string &ownerUid) {
ownerUid_ = ownerUid;
setParameter(std::string("ownerUid"), ownerUid);
}

72
qianzhou/src/model/GetDiagnosisResultResult.cc 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.
*/
#include <alibabacloud/qianzhou/model/GetDiagnosisResultResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
GetDiagnosisResultResult::GetDiagnosisResultResult() :
ServiceResult()
{}
GetDiagnosisResultResult::GetDiagnosisResultResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetDiagnosisResultResult::~GetDiagnosisResultResult()
{}
void GetDiagnosisResultResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
if(!value["data"].isNull())
data_ = value["data"].asString();
if(!value["code"].isNull())
code_ = value["code"].asString();
if(!value["msg"].isNull())
msg_ = value["msg"].asString();
}
std::string GetDiagnosisResultResult::getMsg()const
{
return msg_;
}
std::string GetDiagnosisResultResult::getRequestId()const
{
return requestId_;
}
ObjectOfAny GetDiagnosisResultResult::getData()const
{
return data_;
}
std::string GetDiagnosisResultResult::getCode()const
{
return code_;
}

37
qianzhou/src/model/GetUserClusterWarningRequest.cc Normal file
View File

@@ -0,0 +1,37 @@
/*
* 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/qianzhou/model/GetUserClusterWarningRequest.h>
using AlibabaCloud::Qianzhou::Model::GetUserClusterWarningRequest;
GetUserClusterWarningRequest::GetUserClusterWarningRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/listUserKeyClusters"};
setMethod(HttpRequest::Method::Get);
}
GetUserClusterWarningRequest::~GetUserClusterWarningRequest() {}
std::string GetUserClusterWarningRequest::getUserID() const {
return userID_;
}
void GetUserClusterWarningRequest::setUserID(const std::string &userID) {
userID_ = userID;
setParameter(std::string("userID"), userID);
}

51
qianzhou/src/model/GetUserClusterWarningResult.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/qianzhou/model/GetUserClusterWarningResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
GetUserClusterWarningResult::GetUserClusterWarningResult() :
ServiceResult()
{}
GetUserClusterWarningResult::GetUserClusterWarningResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetUserClusterWarningResult::~GetUserClusterWarningResult()
{}
void GetUserClusterWarningResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
}
std::string GetUserClusterWarningResult::getRequestId()const
{
return requestId_;
}

28
qianzhou/src/model/GetWebshellTokenRequest.cc Normal file
View File

@@ -0,0 +1,28 @@
/*
* 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/qianzhou/model/GetWebshellTokenRequest.h>
using AlibabaCloud::Qianzhou::Model::GetWebshellTokenRequest;
GetWebshellTokenRequest::GetWebshellTokenRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/getChorusToken"};
setMethod(HttpRequest::Method::Get);
}
GetWebshellTokenRequest::~GetWebshellTokenRequest() {}

51
qianzhou/src/model/GetWebshellTokenResult.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/qianzhou/model/GetWebshellTokenResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
GetWebshellTokenResult::GetWebshellTokenResult() :
ServiceResult()
{}
GetWebshellTokenResult::GetWebshellTokenResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetWebshellTokenResult::~GetWebshellTokenResult()
{}
void GetWebshellTokenResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
}
std::string GetWebshellTokenResult::getRequestId()const
{
return requestId_;
}

37
qianzhou/src/model/HelloRequest.cc Normal file
View File

@@ -0,0 +1,37 @@
/*
* 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/qianzhou/model/HelloRequest.h>
using AlibabaCloud::Qianzhou::Model::HelloRequest;
HelloRequest::HelloRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/hello"};
setMethod(HttpRequest::Method::Get);
}
HelloRequest::~HelloRequest() {}
std::string HelloRequest::getUser() const {
return user_;
}
void HelloRequest::setUser(const std::string &user) {
user_ = user;
setParameter(std::string("user"), user);
}

77
qianzhou/src/model/HelloResult.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/qianzhou/model/HelloResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
HelloResult::HelloResult() :
ServiceResult()
{}
HelloResult::HelloResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HelloResult::~HelloResult()
{}
void HelloResult::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["date"].isNull())
data_.date = dataNode["date"].asString();
if(!dataNode["name"].isNull())
data_.name = dataNode["name"].asString();
if(!dataNode["success"].isNull())
data_.success = dataNode["success"].asString() == "true";
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
if(!value["code"].isNull())
code_ = value["code"].asString();
if(!value["msg"].isNull())
msg_ = value["msg"].asString();
}
std::string HelloResult::getMsg()const
{
return msg_;
}
std::string HelloResult::getRequestId()const
{
return requestId_;
}
HelloResult::Data HelloResult::getData()const
{
return data_;
}
std::string HelloResult::getCode()const
{
return code_;
}

64
qianzhou/src/model/ListClusterDeprecatedAPIRequest.cc Normal file
View File

@@ -0,0 +1,64 @@
/*
* 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/qianzhou/model/ListClusterDeprecatedAPIRequest.h>
using AlibabaCloud::Qianzhou::Model::ListClusterDeprecatedAPIRequest;
ListClusterDeprecatedAPIRequest::ListClusterDeprecatedAPIRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/listDeprecatedK8sAPI"};
setMethod(HttpRequest::Method::Post);
}
ListClusterDeprecatedAPIRequest::~ListClusterDeprecatedAPIRequest() {}
std::string ListClusterDeprecatedAPIRequest::getCluster_id() const {
return cluster_id_;
}
void ListClusterDeprecatedAPIRequest::setCluster_id(const std::string &cluster_id) {
cluster_id_ = cluster_id;
setParameter(std::string("cluster_id"), cluster_id);
}
int ListClusterDeprecatedAPIRequest::getPage_no() const {
return page_no_;
}
void ListClusterDeprecatedAPIRequest::setPage_no(int page_no) {
page_no_ = page_no;
setParameter(std::string("page_no"), std::to_string(page_no));
}
std::string ListClusterDeprecatedAPIRequest::getTarget_version() const {
return target_version_;
}
void ListClusterDeprecatedAPIRequest::setTarget_version(const std::string &target_version) {
target_version_ = target_version;
setParameter(std::string("target_version"), target_version);
}
int ListClusterDeprecatedAPIRequest::getPage_size() const {
return page_size_;
}
void ListClusterDeprecatedAPIRequest::setPage_size(int page_size) {
page_size_ = page_size;
setParameter(std::string("page_size"), std::to_string(page_size));
}

107
qianzhou/src/model/ListClusterDeprecatedAPIResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/qianzhou/model/ListClusterDeprecatedAPIResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
ListClusterDeprecatedAPIResult::ListClusterDeprecatedAPIResult() :
ServiceResult()
{}
ListClusterDeprecatedAPIResult::ListClusterDeprecatedAPIResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListClusterDeprecatedAPIResult::~ListClusterDeprecatedAPIResult()
{}
void ListClusterDeprecatedAPIResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto datasNode = value["datas"];
if(!datasNode["total"].isNull())
datas_.total = std::stoi(datasNode["total"].asString());
if(!datasNode["pageSize"].isNull())
datas_.pageSize = std::stoi(datasNode["pageSize"].asString());
if(!datasNode["current"].isNull())
datas_.current = std::stoi(datasNode["current"].asString());
auto alldataNode = datasNode["data"]["dataItem"];
for (auto datasNodedatadataItem : alldataNode)
{
Datas::DataItem dataItemObject;
if(!datasNodedatadataItem["cluster_id"].isNull())
dataItemObject.cluster_id = datasNodedatadataItem["cluster_id"].asString();
if(!datasNodedatadataItem["current_version"].isNull())
dataItemObject.current_version = datasNodedatadataItem["current_version"].asString();
if(!datasNodedatadataItem["target_version"].isNull())
dataItemObject.target_version = datasNodedatadataItem["target_version"].asString();
if(!datasNodedatadataItem["request_uri"].isNull())
dataItemObject.request_uri = datasNodedatadataItem["request_uri"].asString();
if(!datasNodedatadataItem["user_agent"].isNull())
dataItemObject.user_agent = datasNodedatadataItem["user_agent"].asString();
if(!datasNodedatadataItem["label"].isNull())
dataItemObject.label = datasNodedatadataItem["label"].asString();
if(!datasNodedatadataItem["count"].isNull())
dataItemObject.count = std::stoi(datasNodedatadataItem["count"].asString());
if(!datasNodedatadataItem["content"].isNull())
dataItemObject.content = datasNodedatadataItem["content"].asString();
if(!datasNodedatadataItem["deprecated_k8s_version"].isNull())
dataItemObject.deprecated_k8s_version = datasNodedatadataItem["deprecated_k8s_version"].asString();
if(!datasNodedatadataItem["source_ips"].isNull())
dataItemObject.source_ips = datasNodedatadataItem["source_ips"].asString();
if(!datasNodedatadataItem["last_time"].isNull())
dataItemObject.last_time = datasNodedatadataItem["last_time"].asString();
if(!datasNodedatadataItem["ds"].isNull())
dataItemObject.ds = datasNodedatadataItem["ds"].asString();
datas_.data.push_back(dataItemObject);
}
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
if(!value["code"].isNull())
code_ = std::stoi(value["code"].asString());
if(!value["msg"].isNull())
msg_ = value["msg"].asString();
}
std::string ListClusterDeprecatedAPIResult::getMsg()const
{
return msg_;
}
std::string ListClusterDeprecatedAPIResult::getRequestId()const
{
return requestId_;
}
ListClusterDeprecatedAPIResult::Datas ListClusterDeprecatedAPIResult::getDatas()const
{
return datas_;
}
int ListClusterDeprecatedAPIResult::getCode()const
{
return code_;
}

82
qianzhou/src/model/ListClusterImagesRequest.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/qianzhou/model/ListClusterImagesRequest.h>
using AlibabaCloud::Qianzhou::Model::ListClusterImagesRequest;
ListClusterImagesRequest::ListClusterImagesRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/listClusterPodImages"};
setMethod(HttpRequest::Method::Post);
}
ListClusterImagesRequest::~ListClusterImagesRequest() {}
std::string ListClusterImagesRequest::getImage_name() const {
return image_name_;
}
void ListClusterImagesRequest::setImage_name(const std::string &image_name) {
image_name_ = image_name;
setParameter(std::string("image_name"), image_name);
}
std::string ListClusterImagesRequest::getUid() const {
return uid_;
}
void ListClusterImagesRequest::setUid(const std::string &uid) {
uid_ = uid;
setParameter(std::string("uid"), uid);
}
std::string ListClusterImagesRequest::getCluster_id() const {
return cluster_id_;
}
void ListClusterImagesRequest::setCluster_id(const std::string &cluster_id) {
cluster_id_ = cluster_id;
setParameter(std::string("cluster_id"), cluster_id);
}
std::string ListClusterImagesRequest::getImage_hash() const {
return image_hash_;
}
void ListClusterImagesRequest::setImage_hash(const std::string &image_hash) {
image_hash_ = image_hash;
setParameter(std::string("image_hash"), image_hash);
}
int ListClusterImagesRequest::getPage_no() const {
return page_no_;
}
void ListClusterImagesRequest::setPage_no(int page_no) {
page_no_ = page_no;
setParameter(std::string("page_no"), std::to_string(page_no));
}
int ListClusterImagesRequest::getPage_size() const {
return page_size_;
}
void ListClusterImagesRequest::setPage_size(int page_size) {
page_size_ = page_size;
setParameter(std::string("page_size"), std::to_string(page_size));
}

101
qianzhou/src/model/ListClusterImagesResult.cc Normal file
View File

@@ -0,0 +1,101 @@
/*
* 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/qianzhou/model/ListClusterImagesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
ListClusterImagesResult::ListClusterImagesResult() :
ServiceResult()
{}
ListClusterImagesResult::ListClusterImagesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListClusterImagesResult::~ListClusterImagesResult()
{}
void ListClusterImagesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto datasNode = value["datas"];
if(!datasNode["total"].isNull())
datas_.total = std::stoi(datasNode["total"].asString());
if(!datasNode["pageSize"].isNull())
datas_.pageSize = std::stoi(datasNode["pageSize"].asString());
if(!datasNode["current"].isNull())
datas_.current = std::stoi(datasNode["current"].asString());
auto alldataNode = datasNode["data"]["dataItem"];
for (auto datasNodedatadataItem : alldataNode)
{
Datas::DataItem dataItemObject;
if(!datasNodedatadataItem["cluster_id"].isNull())
dataItemObject.cluster_id = datasNodedatadataItem["cluster_id"].asString();
if(!datasNodedatadataItem["namespace"].isNull())
dataItemObject._namespace = datasNodedatadataItem["namespace"].asString();
if(!datasNodedatadataItem["image_name"].isNull())
dataItemObject.image_name = datasNodedatadataItem["image_name"].asString();
if(!datasNodedatadataItem["image_hash"].isNull())
dataItemObject.image_hash = datasNodedatadataItem["image_hash"].asString();
if(!datasNodedatadataItem["controller_type"].isNull())
dataItemObject.controller_type = datasNodedatadataItem["controller_type"].asString();
if(!datasNodedatadataItem["controller_name"].isNull())
dataItemObject.controller_name = datasNodedatadataItem["controller_name"].asString();
if(!datasNodedatadataItem["created"].isNull())
dataItemObject.created = datasNodedatadataItem["created"].asString();
if(!datasNodedatadataItem["updated"].isNull())
dataItemObject.updated = datasNodedatadataItem["updated"].asString();
if(!datasNodedatadataItem["uid"].isNull())
dataItemObject.uid = datasNodedatadataItem["uid"].asString();
datas_.data.push_back(dataItemObject);
}
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
if(!value["code"].isNull())
code_ = std::stoi(value["code"].asString());
if(!value["msg"].isNull())
msg_ = value["msg"].asString();
}
std::string ListClusterImagesResult::getMsg()const
{
return msg_;
}
std::string ListClusterImagesResult::getRequestId()const
{
return requestId_;
}
ListClusterImagesResult::Datas ListClusterImagesResult::getDatas()const
{
return datas_;
}
int ListClusterImagesResult::getCode()const
{
return code_;
}

55
qianzhou/src/model/ListUserClustersRequest.cc Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/qianzhou/model/ListUserClustersRequest.h>
using AlibabaCloud::Qianzhou::Model::ListUserClustersRequest;
ListUserClustersRequest::ListUserClustersRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/listUserClusters"};
setMethod(HttpRequest::Method::Get);
}
ListUserClustersRequest::~ListUserClustersRequest() {}
std::string ListUserClustersRequest::getCurrent() const {
return current_;
}
void ListUserClustersRequest::setCurrent(const std::string &current) {
current_ = current;
setParameter(std::string("current"), current);
}
std::string ListUserClustersRequest::getPageSize() const {
return pageSize_;
}
void ListUserClustersRequest::setPageSize(const std::string &pageSize) {
pageSize_ = pageSize;
setParameter(std::string("pageSize"), pageSize);
}
std::string ListUserClustersRequest::getUserID() const {
return userID_;
}
void ListUserClustersRequest::setUserID(const std::string &userID) {
userID_ = userID;
setParameter(std::string("userID"), userID);
}

72
qianzhou/src/model/ListUserClustersResult.cc 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.
*/
#include <alibabacloud/qianzhou/model/ListUserClustersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
ListUserClustersResult::ListUserClustersResult() :
ServiceResult()
{}
ListUserClustersResult::ListUserClustersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListUserClustersResult::~ListUserClustersResult()
{}
void ListUserClustersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
if(!value["msg"].isNull())
msg_ = value["msg"].asString();
if(!value["data"].isNull())
data_ = value["data"].asString();
if(!value["code"].isNull())
code_ = std::stol(value["code"].asString());
}
std::string ListUserClustersResult::getMsg()const
{
return msg_;
}
std::string ListUserClustersResult::getRequestId()const
{
return requestId_;
}
std::string ListUserClustersResult::getData()const
{
return data_;
}
long ListUserClustersResult::getCode()const
{
return code_;
}

37
qianzhou/src/model/QueryByInstanceInfoRequest.cc Normal file
View File

@@ -0,0 +1,37 @@
/*
* 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/qianzhou/model/QueryByInstanceInfoRequest.h>
using AlibabaCloud::Qianzhou::Model::QueryByInstanceInfoRequest;
QueryByInstanceInfoRequest::QueryByInstanceInfoRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/queryByInstanceInfo"};
setMethod(HttpRequest::Method::Post);
}
QueryByInstanceInfoRequest::~QueryByInstanceInfoRequest() {}
std::string QueryByInstanceInfoRequest::getBody() const {
return body_;
}
void QueryByInstanceInfoRequest::setBody(const std::string &body) {
body_ = body;
setBodyParameter(std::string("body"), body);
}

86
qianzhou/src/model/QueryByInstanceInfoResult.cc Normal file
View File

@@ -0,0 +1,86 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/qianzhou/model/QueryByInstanceInfoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
QueryByInstanceInfoResult::QueryByInstanceInfoResult() :
ServiceResult()
{}
QueryByInstanceInfoResult::QueryByInstanceInfoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryByInstanceInfoResult::~QueryByInstanceInfoResult()
{}
void QueryByInstanceInfoResult::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["clusterId"].isNull())
dataObject.clusterId = valuedatadataItem["clusterId"].asString();
if(!valuedatadataItem["clusterName"].isNull())
dataObject.clusterName = valuedatadataItem["clusterName"].asString();
if(!valuedatadataItem["instanceId"].isNull())
dataObject.instanceId = valuedatadataItem["instanceId"].asString();
if(!valuedatadataItem["regionId"].isNull())
dataObject.regionId = valuedatadataItem["regionId"].asString();
if(!valuedatadataItem["uid"].isNull())
dataObject.uid = valuedatadataItem["uid"].asString();
data_.push_back(dataObject);
}
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
if(!value["code"].isNull())
code_ = std::stoi(value["code"].asString());
if(!value["msg"].isNull())
msg_ = value["msg"].asString();
}
std::string QueryByInstanceInfoResult::getMsg()const
{
return msg_;
}
std::vector<QueryByInstanceInfoResult::DataItem> QueryByInstanceInfoResult::getdata()const
{
return data_;
}
std::string QueryByInstanceInfoResult::getRequestId()const
{
return requestId_;
}
int QueryByInstanceInfoResult::getCode()const
{
return code_;
}

46
qianzhou/src/model/QueryNodeInfoRequest.cc Normal file
View File

@@ -0,0 +1,46 @@
/*
* 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/qianzhou/model/QueryNodeInfoRequest.h>
using AlibabaCloud::Qianzhou::Model::QueryNodeInfoRequest;
QueryNodeInfoRequest::QueryNodeInfoRequest()
: RoaServiceRequest("qianzhou", "2021-11-11") {
setResourcePath("/popapi/queryByInstanceId"};
setMethod(HttpRequest::Method::Get);
}
QueryNodeInfoRequest::~QueryNodeInfoRequest() {}
std::string QueryNodeInfoRequest::getInstanceId() const {
return instanceId_;
}
void QueryNodeInfoRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("instanceId"), instanceId);
}
std::string QueryNodeInfoRequest::getRegionId() const {
return regionId_;
}
void QueryNodeInfoRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("regionId"), regionId);
}

86
qianzhou/src/model/QueryNodeInfoResult.cc Normal file
View File

@@ -0,0 +1,86 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/qianzhou/model/QueryNodeInfoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Qianzhou;
using namespace AlibabaCloud::Qianzhou::Model;
QueryNodeInfoResult::QueryNodeInfoResult() :
ServiceResult()
{}
QueryNodeInfoResult::QueryNodeInfoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryNodeInfoResult::~QueryNodeInfoResult()
{}
void QueryNodeInfoResult::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["clusterId"].isNull())
dataObject.clusterId = valuedatadataItem["clusterId"].asString();
if(!valuedatadataItem["cluserName"].isNull())
dataObject.cluserName = valuedatadataItem["cluserName"].asString();
if(!valuedatadataItem["instanceId"].isNull())
dataObject.instanceId = valuedatadataItem["instanceId"].asString();
if(!valuedatadataItem["region"].isNull())
dataObject.region = valuedatadataItem["region"].asString();
if(!valuedatadataItem["uid"].isNull())
dataObject.uid = valuedatadataItem["uid"].asString();
data_.push_back(dataObject);
}
if(!value["requestId"].isNull())
requestId_ = value["requestId"].asString();
if(!value["code"].isNull())
code_ = std::stoi(value["code"].asString());
if(!value["msg"].isNull())
msg_ = value["msg"].asString();
}
std::string QueryNodeInfoResult::getMsg()const
{
return msg_;
}
std::vector<QueryNodeInfoResult::DataItem> QueryNodeInfoResult::getdata()const
{
return data_;
}
std::string QueryNodeInfoResult::getRequestId()const
{
return requestId_;
}
int QueryNodeInfoResult::getCode()const
{
return code_;
}