From d24791dc627452b87326fb73d62899d3e7df7c5d Mon Sep 17 00:00:00 2001 From: sdk-team Date: Wed, 22 Nov 2023 12:11:51 +0000 Subject: [PATCH] Lindorm open api. --- VERSION | 2 +- hitsdb/CMakeLists.txt | 12 ++ .../alibabacloud/hitsdb/HitsdbClient.h | 24 +++ .../hitsdb/model/CreateLdpsNamespaceRequest.h | 66 ++++++ .../hitsdb/model/CreateLdpsNamespaceResult.h | 49 +++++ .../model/CreateLindormInstanceRequest.h | 6 + .../model/GetInstanceIpWhiteListResult.h | 7 + .../model/GetLdpsNamespacedQuotaRequest.h | 66 ++++++ .../model/GetLdpsNamespacedQuotaResult.h | 59 +++++ .../hitsdb/model/GetLdpsResourceCostRequest.h | 72 +++++++ .../hitsdb/model/GetLdpsResourceCostResult.h | 59 +++++ .../hitsdb/model/GetLindormInstanceResult.h | 12 ++ .../model/ReleaseLindormInstanceRequest.h | 3 + .../model/UpdateInstanceIpWhiteListRequest.h | 3 + .../model/UpgradeLindormInstanceRequest.h | 78 +++---- hitsdb/src/HitsdbClient.cc | 108 ++++++++++ .../src/model/CreateLdpsNamespaceRequest.cc | 108 ++++++++++ hitsdb/src/model/CreateLdpsNamespaceResult.cc | 44 ++++ .../src/model/CreateLindormInstanceRequest.cc | 18 ++ .../src/model/GetInstanceIpWhiteListResult.cc | 15 ++ .../model/GetLdpsNamespacedQuotaRequest.cc | 108 ++++++++++ .../src/model/GetLdpsNamespacedQuotaResult.cc | 65 ++++++ .../src/model/GetLdpsResourceCostRequest.cc | 126 +++++++++++ hitsdb/src/model/GetLdpsResourceCostResult.cc | 79 +++++++ hitsdb/src/model/GetLindormInstanceResult.cc | 42 ++++ .../model/ReleaseLindormInstanceRequest.cc | 9 + .../model/UpdateInstanceIpWhiteListRequest.cc | 9 + .../model/UpgradeLindormInstanceRequest.cc | 202 ++++++++++-------- 28 files changed, 1322 insertions(+), 129 deletions(-) create mode 100644 hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h create mode 100644 hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.h create mode 100644 hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h create mode 100644 hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h create mode 100644 hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h create mode 100644 hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h create mode 100644 hitsdb/src/model/CreateLdpsNamespaceRequest.cc create mode 100644 hitsdb/src/model/CreateLdpsNamespaceResult.cc create mode 100644 hitsdb/src/model/GetLdpsNamespacedQuotaRequest.cc create mode 100644 hitsdb/src/model/GetLdpsNamespacedQuotaResult.cc create mode 100644 hitsdb/src/model/GetLdpsResourceCostRequest.cc create mode 100644 hitsdb/src/model/GetLdpsResourceCostResult.cc diff --git a/VERSION b/VERSION index 1b95e1ead..8679941e7 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1808 \ No newline at end of file +1.36.1809 \ No newline at end of file diff --git a/hitsdb/CMakeLists.txt b/hitsdb/CMakeLists.txt index 5602833fc..279dd63b4 100644 --- a/hitsdb/CMakeLists.txt +++ b/hitsdb/CMakeLists.txt @@ -21,12 +21,18 @@ set(hitsdb_public_header include/alibabacloud/hitsdb/HitsdbExport.h ) set(hitsdb_public_header_model + include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h + include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.h include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h include/alibabacloud/hitsdb/model/CreateLindormInstanceResult.h include/alibabacloud/hitsdb/model/DescribeRegionsRequest.h include/alibabacloud/hitsdb/model/DescribeRegionsResult.h include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListRequest.h include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h + include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h + include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h + include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h + include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h include/alibabacloud/hitsdb/model/GetLindormInstanceRequest.h include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h include/alibabacloud/hitsdb/model/GetLindormInstanceEngineListRequest.h @@ -52,12 +58,18 @@ set(hitsdb_public_header_model set(hitsdb_src src/HitsdbClient.cc + src/model/CreateLdpsNamespaceRequest.cc + src/model/CreateLdpsNamespaceResult.cc src/model/CreateLindormInstanceRequest.cc src/model/CreateLindormInstanceResult.cc src/model/DescribeRegionsRequest.cc src/model/DescribeRegionsResult.cc src/model/GetInstanceIpWhiteListRequest.cc src/model/GetInstanceIpWhiteListResult.cc + src/model/GetLdpsNamespacedQuotaRequest.cc + src/model/GetLdpsNamespacedQuotaResult.cc + src/model/GetLdpsResourceCostRequest.cc + src/model/GetLdpsResourceCostResult.cc src/model/GetLindormInstanceRequest.cc src/model/GetLindormInstanceResult.cc src/model/GetLindormInstanceEngineListRequest.cc diff --git a/hitsdb/include/alibabacloud/hitsdb/HitsdbClient.h b/hitsdb/include/alibabacloud/hitsdb/HitsdbClient.h index e045c544b..3273f7146 100644 --- a/hitsdb/include/alibabacloud/hitsdb/HitsdbClient.h +++ b/hitsdb/include/alibabacloud/hitsdb/HitsdbClient.h @@ -22,12 +22,18 @@ #include #include #include "HitsdbExport.h" +#include "model/CreateLdpsNamespaceRequest.h" +#include "model/CreateLdpsNamespaceResult.h" #include "model/CreateLindormInstanceRequest.h" #include "model/CreateLindormInstanceResult.h" #include "model/DescribeRegionsRequest.h" #include "model/DescribeRegionsResult.h" #include "model/GetInstanceIpWhiteListRequest.h" #include "model/GetInstanceIpWhiteListResult.h" +#include "model/GetLdpsNamespacedQuotaRequest.h" +#include "model/GetLdpsNamespacedQuotaResult.h" +#include "model/GetLdpsResourceCostRequest.h" +#include "model/GetLdpsResourceCostResult.h" #include "model/GetLindormInstanceRequest.h" #include "model/GetLindormInstanceResult.h" #include "model/GetLindormInstanceEngineListRequest.h" @@ -59,6 +65,9 @@ namespace AlibabaCloud class ALIBABACLOUD_HITSDB_EXPORT HitsdbClient : public RpcServiceClient { public: + typedef Outcome CreateLdpsNamespaceOutcome; + typedef std::future CreateLdpsNamespaceOutcomeCallable; + typedef std::function&)> CreateLdpsNamespaceAsyncHandler; typedef Outcome CreateLindormInstanceOutcome; typedef std::future CreateLindormInstanceOutcomeCallable; typedef std::function&)> CreateLindormInstanceAsyncHandler; @@ -68,6 +77,12 @@ namespace AlibabaCloud typedef Outcome GetInstanceIpWhiteListOutcome; typedef std::future GetInstanceIpWhiteListOutcomeCallable; typedef std::function&)> GetInstanceIpWhiteListAsyncHandler; + typedef Outcome GetLdpsNamespacedQuotaOutcome; + typedef std::future GetLdpsNamespacedQuotaOutcomeCallable; + typedef std::function&)> GetLdpsNamespacedQuotaAsyncHandler; + typedef Outcome GetLdpsResourceCostOutcome; + typedef std::future GetLdpsResourceCostOutcomeCallable; + typedef std::function&)> GetLdpsResourceCostAsyncHandler; typedef Outcome GetLindormInstanceOutcome; typedef std::future GetLindormInstanceOutcomeCallable; typedef std::function&)> GetLindormInstanceAsyncHandler; @@ -106,6 +121,9 @@ namespace AlibabaCloud HitsdbClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); HitsdbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); ~HitsdbClient(); + CreateLdpsNamespaceOutcome createLdpsNamespace(const Model::CreateLdpsNamespaceRequest &request)const; + void createLdpsNamespaceAsync(const Model::CreateLdpsNamespaceRequest& request, const CreateLdpsNamespaceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateLdpsNamespaceOutcomeCallable createLdpsNamespaceCallable(const Model::CreateLdpsNamespaceRequest& request) const; CreateLindormInstanceOutcome createLindormInstance(const Model::CreateLindormInstanceRequest &request)const; void createLindormInstanceAsync(const Model::CreateLindormInstanceRequest& request, const CreateLindormInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateLindormInstanceOutcomeCallable createLindormInstanceCallable(const Model::CreateLindormInstanceRequest& request) const; @@ -115,6 +133,12 @@ namespace AlibabaCloud GetInstanceIpWhiteListOutcome getInstanceIpWhiteList(const Model::GetInstanceIpWhiteListRequest &request)const; void getInstanceIpWhiteListAsync(const Model::GetInstanceIpWhiteListRequest& request, const GetInstanceIpWhiteListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetInstanceIpWhiteListOutcomeCallable getInstanceIpWhiteListCallable(const Model::GetInstanceIpWhiteListRequest& request) const; + GetLdpsNamespacedQuotaOutcome getLdpsNamespacedQuota(const Model::GetLdpsNamespacedQuotaRequest &request)const; + void getLdpsNamespacedQuotaAsync(const Model::GetLdpsNamespacedQuotaRequest& request, const GetLdpsNamespacedQuotaAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetLdpsNamespacedQuotaOutcomeCallable getLdpsNamespacedQuotaCallable(const Model::GetLdpsNamespacedQuotaRequest& request) const; + GetLdpsResourceCostOutcome getLdpsResourceCost(const Model::GetLdpsResourceCostRequest &request)const; + void getLdpsResourceCostAsync(const Model::GetLdpsResourceCostRequest& request, const GetLdpsResourceCostAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetLdpsResourceCostOutcomeCallable getLdpsResourceCostCallable(const Model::GetLdpsResourceCostRequest& request) const; GetLindormInstanceOutcome getLindormInstance(const Model::GetLindormInstanceRequest &request)const; void getLindormInstanceAsync(const Model::GetLindormInstanceRequest& request, const GetLindormInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetLindormInstanceOutcomeCallable getLindormInstanceCallable(const Model::GetLindormInstanceRequest& request) const; diff --git a/hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h b/hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h new file mode 100644 index 000000000..2940c3f2e --- /dev/null +++ b/hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h @@ -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_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_ +#define ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Hitsdb { +namespace Model { +class ALIBABACLOUD_HITSDB_EXPORT CreateLdpsNamespaceRequest : public RpcServiceRequest { +public: + CreateLdpsNamespaceRequest(); + ~CreateLdpsNamespaceRequest(); + long getResourceOwnerId() const; + void setResourceOwnerId(long resourceOwnerId); + std::string getAccessKeyId() const; + void setAccessKeyId(const std::string &accessKeyId); + std::string getSecurityToken() const; + void setSecurityToken(const std::string &securityToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getResourceOwnerAccount() const; + void setResourceOwnerAccount(const std::string &resourceOwnerAccount); + std::string getOwnerAccount() const; + void setOwnerAccount(const std::string &ownerAccount); + long getOwnerId() const; + void setOwnerId(long ownerId); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + +private: + long resourceOwnerId_; + std::string accessKeyId_; + std::string securityToken_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string instanceId_; + std::string _namespace_; +}; +} // namespace Model +} // namespace Hitsdb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_ diff --git a/hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.h b/hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.h new file mode 100644 index 000000000..4d485c3ea --- /dev/null +++ b/hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_ +#define ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Hitsdb + { + namespace Model + { + class ALIBABACLOUD_HITSDB_EXPORT CreateLdpsNamespaceResult : public ServiceResult + { + public: + + + CreateLdpsNamespaceResult(); + explicit CreateLdpsNamespaceResult(const std::string &payload); + ~CreateLdpsNamespaceResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_ \ No newline at end of file diff --git a/hitsdb/include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h b/hitsdb/include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h index 2a15ae47c..caf56b955 100644 --- a/hitsdb/include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h +++ b/hitsdb/include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h @@ -54,6 +54,8 @@ public: void setLindormNum(int lindormNum); std::string getVSwitchId() const; void setVSwitchId(const std::string &vSwitchId); + int getStreamNum() const; + void setStreamNum(int streamNum); int getLogSingleStorage() const; void setLogSingleStorage(int logSingleStorage); std::string getZoneId() const; @@ -104,6 +106,8 @@ public: void setInstanceAlias(const std::string &instanceAlias); int getFilestoreNum() const; void setFilestoreNum(int filestoreNum); + std::string getStreamSpec() const; + void setStreamSpec(const std::string &streamSpec); std::string getCoreSpec() const; void setCoreSpec(const std::string &coreSpec); std::string getVPCId() const; @@ -126,6 +130,7 @@ private: long ownerId_; int lindormNum_; std::string vSwitchId_; + int streamNum_; int logSingleStorage_; std::string zoneId_; std::string arbiterZoneId_; @@ -151,6 +156,7 @@ private: std::string ownerAccount_; std::string instanceAlias_; int filestoreNum_; + std::string streamSpec_; std::string coreSpec_; std::string vPCId_; std::string payType_; diff --git a/hitsdb/include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h b/hitsdb/include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h index 1e6b4b5ab..5ddb01021 100644 --- a/hitsdb/include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h +++ b/hitsdb/include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h @@ -32,17 +32,24 @@ namespace AlibabaCloud class ALIBABACLOUD_HITSDB_EXPORT GetInstanceIpWhiteListResult : public ServiceResult { public: + struct GroupListItem + { + std::string groupName; + std::string securityIpList; + }; GetInstanceIpWhiteListResult(); explicit GetInstanceIpWhiteListResult(const std::string &payload); ~GetInstanceIpWhiteListResult(); + std::vector getGroupList()const; std::vector getIpList()const; std::string getInstanceId()const; protected: void parse(const std::string &payload); private: + std::vector groupList_; std::vector ipList_; std::string instanceId_; diff --git a/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h b/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h new file mode 100644 index 000000000..545da2c9a --- /dev/null +++ b/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h @@ -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_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_ +#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Hitsdb { +namespace Model { +class ALIBABACLOUD_HITSDB_EXPORT GetLdpsNamespacedQuotaRequest : public RpcServiceRequest { +public: + GetLdpsNamespacedQuotaRequest(); + ~GetLdpsNamespacedQuotaRequest(); + long getResourceOwnerId() const; + void setResourceOwnerId(long resourceOwnerId); + std::string getAccessKeyId() const; + void setAccessKeyId(const std::string &accessKeyId); + std::string getSecurityToken() const; + void setSecurityToken(const std::string &securityToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getResourceOwnerAccount() const; + void setResourceOwnerAccount(const std::string &resourceOwnerAccount); + std::string getOwnerAccount() const; + void setOwnerAccount(const std::string &ownerAccount); + long getOwnerId() const; + void setOwnerId(long ownerId); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + +private: + long resourceOwnerId_; + std::string accessKeyId_; + std::string securityToken_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string instanceId_; + std::string _namespace_; +}; +} // namespace Model +} // namespace Hitsdb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_ diff --git a/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h b/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h new file mode 100644 index 000000000..c29d90ddb --- /dev/null +++ b/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h @@ -0,0 +1,59 @@ +/* + * 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_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_ +#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Hitsdb + { + namespace Model + { + class ALIBABACLOUD_HITSDB_EXPORT GetLdpsNamespacedQuotaResult : public ServiceResult + { + public: + struct NamespacedQuota + { + std::string usedMemory; + std::string cpuAmount; + std::string usedCpu; + std::string memoryAmount; + std::string name; + }; + + + GetLdpsNamespacedQuotaResult(); + explicit GetLdpsNamespacedQuotaResult(const std::string &payload); + ~GetLdpsNamespacedQuotaResult(); + std::vector getNamespacedQuotas()const; + + protected: + void parse(const std::string &payload); + private: + std::vector namespacedQuotas_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_ \ No newline at end of file diff --git a/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h b/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h new file mode 100644 index 000000000..9798cf14f --- /dev/null +++ b/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_ +#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Hitsdb { +namespace Model { +class ALIBABACLOUD_HITSDB_EXPORT GetLdpsResourceCostRequest : public RpcServiceRequest { +public: + GetLdpsResourceCostRequest(); + ~GetLdpsResourceCostRequest(); + long getResourceOwnerId() const; + void setResourceOwnerId(long resourceOwnerId); + long getStartTime() const; + void setStartTime(long startTime); + std::string getAccessKeyId() const; + void setAccessKeyId(const std::string &accessKeyId); + std::string getJobId() const; + void setJobId(const std::string &jobId); + std::string getSecurityToken() const; + void setSecurityToken(const std::string &securityToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getResourceOwnerAccount() const; + void setResourceOwnerAccount(const std::string &resourceOwnerAccount); + std::string getOwnerAccount() const; + void setOwnerAccount(const std::string &ownerAccount); + long getEndTime() const; + void setEndTime(long endTime); + long getOwnerId() const; + void setOwnerId(long ownerId); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + +private: + long resourceOwnerId_; + long startTime_; + std::string accessKeyId_; + std::string jobId_; + std::string securityToken_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long endTime_; + long ownerId_; + std::string instanceId_; +}; +} // namespace Model +} // namespace Hitsdb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_ diff --git a/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h b/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h new file mode 100644 index 000000000..a1afa5967 --- /dev/null +++ b/hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h @@ -0,0 +1,59 @@ +/* + * 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_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_ +#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Hitsdb + { + namespace Model + { + class ALIBABACLOUD_HITSDB_EXPORT GetLdpsResourceCostResult : public ServiceResult + { + public: + + + GetLdpsResourceCostResult(); + explicit GetLdpsResourceCostResult(const std::string &payload); + ~GetLdpsResourceCostResult(); + long getEndTime()const; + std::string getInstanceId()const; + long getStartTime()const; + long getTotalResource()const; + std::string getJobId()const; + + protected: + void parse(const std::string &payload); + private: + long endTime_; + std::string instanceId_; + long startTime_; + long totalResource_; + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_ \ No newline at end of file diff --git a/hitsdb/include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h b/hitsdb/include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h index 5582783ae..5887d06ad 100644 --- a/hitsdb/include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h +++ b/hitsdb/include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h @@ -50,6 +50,7 @@ namespace AlibabaCloud long getExpiredMilliseconds()const; std::string getStandbyZoneId()const; std::vector getEngineList()const; + bool getEnableLTS()const; std::string getResourceGroupId()const; bool getEnableBDS()const; std::string getLogDiskCategory()const; @@ -74,13 +75,17 @@ namespace AlibabaCloud std::string getArbiterVSwitchId()const; std::string getVpcId()const; bool getEnableCdc()const; + bool getEnableMLCtrl()const; bool getEnableStream()const; bool getEnablePhoenix()const; int getLogSingleStorage()const; std::string getExpireTime()const; + bool getEnableML()const; int getLogNum()const; int getLocalCloudStorage()const; + bool getEnableBlob()const; std::string getDiskThreshold()const; + bool getEnableLsqlVersionV3()const; bool getAutoRenew()const; bool getEnableShs()const; std::string getMaintainEndTime()const; @@ -94,6 +99,7 @@ namespace AlibabaCloud std::string getMultiZoneCombination()const; bool getEnableKms()const; int getCoreNum()const; + std::string getArchVersion()const; std::string getCreateTime()const; std::string getLogSpec()const; std::string getLocalCloudCategory()const; @@ -107,6 +113,7 @@ namespace AlibabaCloud long expiredMilliseconds_; std::string standbyZoneId_; std::vector engineList_; + bool enableLTS_; std::string resourceGroupId_; bool enableBDS_; std::string logDiskCategory_; @@ -131,13 +138,17 @@ namespace AlibabaCloud std::string arbiterVSwitchId_; std::string vpcId_; bool enableCdc_; + bool enableMLCtrl_; bool enableStream_; bool enablePhoenix_; int logSingleStorage_; std::string expireTime_; + bool enableML_; int logNum_; int localCloudStorage_; + bool enableBlob_; std::string diskThreshold_; + bool enableLsqlVersionV3_; bool autoRenew_; bool enableShs_; std::string maintainEndTime_; @@ -151,6 +162,7 @@ namespace AlibabaCloud std::string multiZoneCombination_; bool enableKms_; int coreNum_; + std::string archVersion_; std::string createTime_; std::string logSpec_; std::string localCloudCategory_; diff --git a/hitsdb/include/alibabacloud/hitsdb/model/ReleaseLindormInstanceRequest.h b/hitsdb/include/alibabacloud/hitsdb/model/ReleaseLindormInstanceRequest.h index 5c0e95672..b6cb639b7 100644 --- a/hitsdb/include/alibabacloud/hitsdb/model/ReleaseLindormInstanceRequest.h +++ b/hitsdb/include/alibabacloud/hitsdb/model/ReleaseLindormInstanceRequest.h @@ -32,6 +32,8 @@ public: ~ReleaseLindormInstanceRequest(); long getResourceOwnerId() const; void setResourceOwnerId(long resourceOwnerId); + bool getImmediately() const; + void setImmediately(bool immediately); std::string getAccessKeyId() const; void setAccessKeyId(const std::string &accessKeyId); std::string getSecurityToken() const; @@ -47,6 +49,7 @@ public: private: long resourceOwnerId_; + bool immediately_; std::string accessKeyId_; std::string securityToken_; std::string resourceOwnerAccount_; diff --git a/hitsdb/include/alibabacloud/hitsdb/model/UpdateInstanceIpWhiteListRequest.h b/hitsdb/include/alibabacloud/hitsdb/model/UpdateInstanceIpWhiteListRequest.h index fd854adf3..ca342c9d7 100644 --- a/hitsdb/include/alibabacloud/hitsdb/model/UpdateInstanceIpWhiteListRequest.h +++ b/hitsdb/include/alibabacloud/hitsdb/model/UpdateInstanceIpWhiteListRequest.h @@ -32,6 +32,8 @@ public: ~UpdateInstanceIpWhiteListRequest(); long getResourceOwnerId() const; void setResourceOwnerId(long resourceOwnerId); + bool get_Delete() const; + void set_Delete(bool _delete); std::string getAccessKeyId() const; void setAccessKeyId(const std::string &accessKeyId); std::string getSecurityToken() const; @@ -51,6 +53,7 @@ public: private: long resourceOwnerId_; + bool _delete_; std::string accessKeyId_; std::string securityToken_; std::string resourceOwnerAccount_; diff --git a/hitsdb/include/alibabacloud/hitsdb/model/UpgradeLindormInstanceRequest.h b/hitsdb/include/alibabacloud/hitsdb/model/UpgradeLindormInstanceRequest.h index 27e936656..e162cebfc 100644 --- a/hitsdb/include/alibabacloud/hitsdb/model/UpgradeLindormInstanceRequest.h +++ b/hitsdb/include/alibabacloud/hitsdb/model/UpgradeLindormInstanceRequest.h @@ -32,10 +32,30 @@ public: ~UpgradeLindormInstanceRequest(); long getResourceOwnerId() const; void setResourceOwnerId(long resourceOwnerId); - int getPhoenixCoreNum() const; - void setPhoenixCoreNum(int phoenixCoreNum); - std::string getPhoenixCoreSpec() const; - void setPhoenixCoreSpec(const std::string &phoenixCoreSpec); + std::string getLogSpec() const; + void setLogSpec(const std::string &logSpec); + std::string getSecurityToken() const; + void setSecurityToken(const std::string &securityToken); + int getTsdbNum() const; + void setTsdbNum(int tsdbNum); + int getSolrNum() const; + void setSolrNum(int solrNum); + long getOwnerId() const; + void setOwnerId(long ownerId); + int getLindormNum() const; + void setLindormNum(int lindormNum); + int getLtsCoreNum() const; + void setLtsCoreNum(int ltsCoreNum); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + int getMlNum() const; + void setMlNum(int mlNum); + int getStreamNum() const; + void setStreamNum(int streamNum); + int getLogSingleStorage() const; + void setLogSingleStorage(int logSingleStorage); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); std::string getClientToken() const; void setClientToken(const std::string &clientToken); std::string getUpgradeType() const; @@ -46,18 +66,10 @@ public: void setFilestoreSpec(const std::string &filestoreSpec); std::string getAccessKeyId() const; void setAccessKeyId(const std::string &accessKeyId); - std::string getLogSpec() const; - void setLogSpec(const std::string &logSpec); - std::string getSecurityToken() const; - void setSecurityToken(const std::string &securityToken); std::string getRegionId() const; void setRegionId(const std::string ®ionId); - int getTsdbNum() const; - void setTsdbNum(int tsdbNum); std::string getLindormSpec() const; void setLindormSpec(const std::string &lindormSpec); - int getSolrNum() const; - void setSolrNum(int solrNum); int getColdStorage() const; void setColdStorage(int coldStorage); int getLogNum() const; @@ -72,38 +84,36 @@ public: void setOwnerAccount(const std::string &ownerAccount); int getFilestoreNum() const; void setFilestoreNum(int filestoreNum); - long getOwnerId() const; - void setOwnerId(long ownerId); - int getLindormNum() const; - void setLindormNum(int lindormNum); - int getLtsCoreNum() const; - void setLtsCoreNum(int ltsCoreNum); - std::string getInstanceId() const; - void setInstanceId(const std::string &instanceId); + std::string getStreamSpec() const; + void setStreamSpec(const std::string &streamSpec); + std::string getMlSpec() const; + void setMlSpec(const std::string &mlSpec); std::string getLtsCoreSpec() const; void setLtsCoreSpec(const std::string <sCoreSpec); int getClusterStorage() const; void setClusterStorage(int clusterStorage); - int getLogSingleStorage() const; - void setLogSingleStorage(int logSingleStorage); - std::string getZoneId() const; - void setZoneId(const std::string &zoneId); private: long resourceOwnerId_; - int phoenixCoreNum_; - std::string phoenixCoreSpec_; + std::string logSpec_; + std::string securityToken_; + int tsdbNum_; + int solrNum_; + long ownerId_; + int lindormNum_; + int ltsCoreNum_; + std::string instanceId_; + int mlNum_; + int streamNum_; + int logSingleStorage_; + std::string zoneId_; std::string clientToken_; std::string upgradeType_; std::string tsdbSpec_; std::string filestoreSpec_; std::string accessKeyId_; - std::string logSpec_; - std::string securityToken_; std::string regionId_; - int tsdbNum_; std::string lindormSpec_; - int solrNum_; int coldStorage_; int logNum_; std::string solrSpec_; @@ -111,14 +121,10 @@ private: std::string resourceOwnerAccount_; std::string ownerAccount_; int filestoreNum_; - long ownerId_; - int lindormNum_; - int ltsCoreNum_; - std::string instanceId_; + std::string streamSpec_; + std::string mlSpec_; std::string ltsCoreSpec_; int clusterStorage_; - int logSingleStorage_; - std::string zoneId_; }; } // namespace Model } // namespace Hitsdb diff --git a/hitsdb/src/HitsdbClient.cc b/hitsdb/src/HitsdbClient.cc index 97188c5c8..4997577eb 100644 --- a/hitsdb/src/HitsdbClient.cc +++ b/hitsdb/src/HitsdbClient.cc @@ -51,6 +51,42 @@ HitsdbClient::HitsdbClient(const std::string & accessKeyId, const std::string & HitsdbClient::~HitsdbClient() {} +HitsdbClient::CreateLdpsNamespaceOutcome HitsdbClient::createLdpsNamespace(const CreateLdpsNamespaceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateLdpsNamespaceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateLdpsNamespaceOutcome(CreateLdpsNamespaceResult(outcome.result())); + else + return CreateLdpsNamespaceOutcome(outcome.error()); +} + +void HitsdbClient::createLdpsNamespaceAsync(const CreateLdpsNamespaceRequest& request, const CreateLdpsNamespaceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createLdpsNamespace(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HitsdbClient::CreateLdpsNamespaceOutcomeCallable HitsdbClient::createLdpsNamespaceCallable(const CreateLdpsNamespaceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createLdpsNamespace(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + HitsdbClient::CreateLindormInstanceOutcome HitsdbClient::createLindormInstance(const CreateLindormInstanceRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -159,6 +195,78 @@ HitsdbClient::GetInstanceIpWhiteListOutcomeCallable HitsdbClient::getInstanceIpW return task->get_future(); } +HitsdbClient::GetLdpsNamespacedQuotaOutcome HitsdbClient::getLdpsNamespacedQuota(const GetLdpsNamespacedQuotaRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetLdpsNamespacedQuotaOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetLdpsNamespacedQuotaOutcome(GetLdpsNamespacedQuotaResult(outcome.result())); + else + return GetLdpsNamespacedQuotaOutcome(outcome.error()); +} + +void HitsdbClient::getLdpsNamespacedQuotaAsync(const GetLdpsNamespacedQuotaRequest& request, const GetLdpsNamespacedQuotaAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getLdpsNamespacedQuota(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HitsdbClient::GetLdpsNamespacedQuotaOutcomeCallable HitsdbClient::getLdpsNamespacedQuotaCallable(const GetLdpsNamespacedQuotaRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getLdpsNamespacedQuota(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HitsdbClient::GetLdpsResourceCostOutcome HitsdbClient::getLdpsResourceCost(const GetLdpsResourceCostRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetLdpsResourceCostOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetLdpsResourceCostOutcome(GetLdpsResourceCostResult(outcome.result())); + else + return GetLdpsResourceCostOutcome(outcome.error()); +} + +void HitsdbClient::getLdpsResourceCostAsync(const GetLdpsResourceCostRequest& request, const GetLdpsResourceCostAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getLdpsResourceCost(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HitsdbClient::GetLdpsResourceCostOutcomeCallable HitsdbClient::getLdpsResourceCostCallable(const GetLdpsResourceCostRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getLdpsResourceCost(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + HitsdbClient::GetLindormInstanceOutcome HitsdbClient::getLindormInstance(const GetLindormInstanceRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/hitsdb/src/model/CreateLdpsNamespaceRequest.cc b/hitsdb/src/model/CreateLdpsNamespaceRequest.cc new file mode 100644 index 000000000..10840ed20 --- /dev/null +++ b/hitsdb/src/model/CreateLdpsNamespaceRequest.cc @@ -0,0 +1,108 @@ +/* + * 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 + +using AlibabaCloud::Hitsdb::Model::CreateLdpsNamespaceRequest; + +CreateLdpsNamespaceRequest::CreateLdpsNamespaceRequest() + : RpcServiceRequest("hitsdb", "2020-06-15", "CreateLdpsNamespace") { + setMethod(HttpRequest::Method::Post); +} + +CreateLdpsNamespaceRequest::~CreateLdpsNamespaceRequest() {} + +long CreateLdpsNamespaceRequest::getResourceOwnerId() const { + return resourceOwnerId_; +} + +void CreateLdpsNamespaceRequest::setResourceOwnerId(long resourceOwnerId) { + resourceOwnerId_ = resourceOwnerId; + setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); +} + +std::string CreateLdpsNamespaceRequest::getAccessKeyId() const { + return accessKeyId_; +} + +void CreateLdpsNamespaceRequest::setAccessKeyId(const std::string &accessKeyId) { + accessKeyId_ = accessKeyId; + setParameter(std::string("AccessKeyId"), accessKeyId); +} + +std::string CreateLdpsNamespaceRequest::getSecurityToken() const { + return securityToken_; +} + +void CreateLdpsNamespaceRequest::setSecurityToken(const std::string &securityToken) { + securityToken_ = securityToken; + setParameter(std::string("SecurityToken"), securityToken); +} + +std::string CreateLdpsNamespaceRequest::getRegionId() const { + return regionId_; +} + +void CreateLdpsNamespaceRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string CreateLdpsNamespaceRequest::getResourceOwnerAccount() const { + return resourceOwnerAccount_; +} + +void CreateLdpsNamespaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) { + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount); +} + +std::string CreateLdpsNamespaceRequest::getOwnerAccount() const { + return ownerAccount_; +} + +void CreateLdpsNamespaceRequest::setOwnerAccount(const std::string &ownerAccount) { + ownerAccount_ = ownerAccount; + setParameter(std::string("OwnerAccount"), ownerAccount); +} + +long CreateLdpsNamespaceRequest::getOwnerId() const { + return ownerId_; +} + +void CreateLdpsNamespaceRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + +std::string CreateLdpsNamespaceRequest::getInstanceId() const { + return instanceId_; +} + +void CreateLdpsNamespaceRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setParameter(std::string("InstanceId"), instanceId); +} + +std::string CreateLdpsNamespaceRequest::get_Namespace() const { + return _namespace_; +} + +void CreateLdpsNamespaceRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + diff --git a/hitsdb/src/model/CreateLdpsNamespaceResult.cc b/hitsdb/src/model/CreateLdpsNamespaceResult.cc new file mode 100644 index 000000000..cc9aeaef0 --- /dev/null +++ b/hitsdb/src/model/CreateLdpsNamespaceResult.cc @@ -0,0 +1,44 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Hitsdb; +using namespace AlibabaCloud::Hitsdb::Model; + +CreateLdpsNamespaceResult::CreateLdpsNamespaceResult() : + ServiceResult() +{} + +CreateLdpsNamespaceResult::CreateLdpsNamespaceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateLdpsNamespaceResult::~CreateLdpsNamespaceResult() +{} + +void CreateLdpsNamespaceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/hitsdb/src/model/CreateLindormInstanceRequest.cc b/hitsdb/src/model/CreateLindormInstanceRequest.cc index d0390e6f0..d66cabbf9 100644 --- a/hitsdb/src/model/CreateLindormInstanceRequest.cc +++ b/hitsdb/src/model/CreateLindormInstanceRequest.cc @@ -133,6 +133,15 @@ void CreateLindormInstanceRequest::setVSwitchId(const std::string &vSwitchId) { setParameter(std::string("VSwitchId"), vSwitchId); } +int CreateLindormInstanceRequest::getStreamNum() const { + return streamNum_; +} + +void CreateLindormInstanceRequest::setStreamNum(int streamNum) { + streamNum_ = streamNum; + setParameter(std::string("StreamNum"), std::to_string(streamNum)); +} + int CreateLindormInstanceRequest::getLogSingleStorage() const { return logSingleStorage_; } @@ -358,6 +367,15 @@ void CreateLindormInstanceRequest::setFilestoreNum(int filestoreNum) { setParameter(std::string("FilestoreNum"), std::to_string(filestoreNum)); } +std::string CreateLindormInstanceRequest::getStreamSpec() const { + return streamSpec_; +} + +void CreateLindormInstanceRequest::setStreamSpec(const std::string &streamSpec) { + streamSpec_ = streamSpec; + setParameter(std::string("StreamSpec"), streamSpec); +} + std::string CreateLindormInstanceRequest::getCoreSpec() const { return coreSpec_; } diff --git a/hitsdb/src/model/GetInstanceIpWhiteListResult.cc b/hitsdb/src/model/GetInstanceIpWhiteListResult.cc index 963146ef9..04c2e5a13 100644 --- a/hitsdb/src/model/GetInstanceIpWhiteListResult.cc +++ b/hitsdb/src/model/GetInstanceIpWhiteListResult.cc @@ -39,6 +39,16 @@ void GetInstanceIpWhiteListResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); + auto allGroupListNode = value["GroupList"]["GroupListItem"]; + for (auto valueGroupListGroupListItem : allGroupListNode) + { + GroupListItem groupListObject; + if(!valueGroupListGroupListItem["GroupName"].isNull()) + groupListObject.groupName = valueGroupListGroupListItem["GroupName"].asString(); + if(!valueGroupListGroupListItem["SecurityIpList"].isNull()) + groupListObject.securityIpList = valueGroupListGroupListItem["SecurityIpList"].asString(); + groupList_.push_back(groupListObject); + } auto allIpList = value["IpList"]["IpList"]; for (const auto &item : allIpList) ipList_.push_back(item.asString()); @@ -47,6 +57,11 @@ void GetInstanceIpWhiteListResult::parse(const std::string &payload) } +std::vector GetInstanceIpWhiteListResult::getGroupList()const +{ + return groupList_; +} + std::vector GetInstanceIpWhiteListResult::getIpList()const { return ipList_; diff --git a/hitsdb/src/model/GetLdpsNamespacedQuotaRequest.cc b/hitsdb/src/model/GetLdpsNamespacedQuotaRequest.cc new file mode 100644 index 000000000..7860fb7d0 --- /dev/null +++ b/hitsdb/src/model/GetLdpsNamespacedQuotaRequest.cc @@ -0,0 +1,108 @@ +/* + * 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 + +using AlibabaCloud::Hitsdb::Model::GetLdpsNamespacedQuotaRequest; + +GetLdpsNamespacedQuotaRequest::GetLdpsNamespacedQuotaRequest() + : RpcServiceRequest("hitsdb", "2020-06-15", "GetLdpsNamespacedQuota") { + setMethod(HttpRequest::Method::Post); +} + +GetLdpsNamespacedQuotaRequest::~GetLdpsNamespacedQuotaRequest() {} + +long GetLdpsNamespacedQuotaRequest::getResourceOwnerId() const { + return resourceOwnerId_; +} + +void GetLdpsNamespacedQuotaRequest::setResourceOwnerId(long resourceOwnerId) { + resourceOwnerId_ = resourceOwnerId; + setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); +} + +std::string GetLdpsNamespacedQuotaRequest::getAccessKeyId() const { + return accessKeyId_; +} + +void GetLdpsNamespacedQuotaRequest::setAccessKeyId(const std::string &accessKeyId) { + accessKeyId_ = accessKeyId; + setParameter(std::string("AccessKeyId"), accessKeyId); +} + +std::string GetLdpsNamespacedQuotaRequest::getSecurityToken() const { + return securityToken_; +} + +void GetLdpsNamespacedQuotaRequest::setSecurityToken(const std::string &securityToken) { + securityToken_ = securityToken; + setParameter(std::string("SecurityToken"), securityToken); +} + +std::string GetLdpsNamespacedQuotaRequest::getRegionId() const { + return regionId_; +} + +void GetLdpsNamespacedQuotaRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string GetLdpsNamespacedQuotaRequest::getResourceOwnerAccount() const { + return resourceOwnerAccount_; +} + +void GetLdpsNamespacedQuotaRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) { + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount); +} + +std::string GetLdpsNamespacedQuotaRequest::getOwnerAccount() const { + return ownerAccount_; +} + +void GetLdpsNamespacedQuotaRequest::setOwnerAccount(const std::string &ownerAccount) { + ownerAccount_ = ownerAccount; + setParameter(std::string("OwnerAccount"), ownerAccount); +} + +long GetLdpsNamespacedQuotaRequest::getOwnerId() const { + return ownerId_; +} + +void GetLdpsNamespacedQuotaRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + +std::string GetLdpsNamespacedQuotaRequest::getInstanceId() const { + return instanceId_; +} + +void GetLdpsNamespacedQuotaRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setParameter(std::string("InstanceId"), instanceId); +} + +std::string GetLdpsNamespacedQuotaRequest::get_Namespace() const { + return _namespace_; +} + +void GetLdpsNamespacedQuotaRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + diff --git a/hitsdb/src/model/GetLdpsNamespacedQuotaResult.cc b/hitsdb/src/model/GetLdpsNamespacedQuotaResult.cc new file mode 100644 index 000000000..a5f0decd2 --- /dev/null +++ b/hitsdb/src/model/GetLdpsNamespacedQuotaResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Hitsdb; +using namespace AlibabaCloud::Hitsdb::Model; + +GetLdpsNamespacedQuotaResult::GetLdpsNamespacedQuotaResult() : + ServiceResult() +{} + +GetLdpsNamespacedQuotaResult::GetLdpsNamespacedQuotaResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetLdpsNamespacedQuotaResult::~GetLdpsNamespacedQuotaResult() +{} + +void GetLdpsNamespacedQuotaResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allNamespacedQuotasNode = value["NamespacedQuotas"]["NamespacedQuota"]; + for (auto valueNamespacedQuotasNamespacedQuota : allNamespacedQuotasNode) + { + NamespacedQuota namespacedQuotasObject; + if(!valueNamespacedQuotasNamespacedQuota["Name"].isNull()) + namespacedQuotasObject.name = valueNamespacedQuotasNamespacedQuota["Name"].asString(); + if(!valueNamespacedQuotasNamespacedQuota["CpuAmount"].isNull()) + namespacedQuotasObject.cpuAmount = valueNamespacedQuotasNamespacedQuota["CpuAmount"].asString(); + if(!valueNamespacedQuotasNamespacedQuota["MemoryAmount"].isNull()) + namespacedQuotasObject.memoryAmount = valueNamespacedQuotasNamespacedQuota["MemoryAmount"].asString(); + if(!valueNamespacedQuotasNamespacedQuota["UsedCpu"].isNull()) + namespacedQuotasObject.usedCpu = valueNamespacedQuotasNamespacedQuota["UsedCpu"].asString(); + if(!valueNamespacedQuotasNamespacedQuota["UsedMemory"].isNull()) + namespacedQuotasObject.usedMemory = valueNamespacedQuotasNamespacedQuota["UsedMemory"].asString(); + namespacedQuotas_.push_back(namespacedQuotasObject); + } + +} + +std::vector GetLdpsNamespacedQuotaResult::getNamespacedQuotas()const +{ + return namespacedQuotas_; +} + diff --git a/hitsdb/src/model/GetLdpsResourceCostRequest.cc b/hitsdb/src/model/GetLdpsResourceCostRequest.cc new file mode 100644 index 000000000..778a70ebe --- /dev/null +++ b/hitsdb/src/model/GetLdpsResourceCostRequest.cc @@ -0,0 +1,126 @@ +/* + * 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 + +using AlibabaCloud::Hitsdb::Model::GetLdpsResourceCostRequest; + +GetLdpsResourceCostRequest::GetLdpsResourceCostRequest() + : RpcServiceRequest("hitsdb", "2020-06-15", "GetLdpsResourceCost") { + setMethod(HttpRequest::Method::Post); +} + +GetLdpsResourceCostRequest::~GetLdpsResourceCostRequest() {} + +long GetLdpsResourceCostRequest::getResourceOwnerId() const { + return resourceOwnerId_; +} + +void GetLdpsResourceCostRequest::setResourceOwnerId(long resourceOwnerId) { + resourceOwnerId_ = resourceOwnerId; + setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); +} + +long GetLdpsResourceCostRequest::getStartTime() const { + return startTime_; +} + +void GetLdpsResourceCostRequest::setStartTime(long startTime) { + startTime_ = startTime; + setParameter(std::string("StartTime"), std::to_string(startTime)); +} + +std::string GetLdpsResourceCostRequest::getAccessKeyId() const { + return accessKeyId_; +} + +void GetLdpsResourceCostRequest::setAccessKeyId(const std::string &accessKeyId) { + accessKeyId_ = accessKeyId; + setParameter(std::string("AccessKeyId"), accessKeyId); +} + +std::string GetLdpsResourceCostRequest::getJobId() const { + return jobId_; +} + +void GetLdpsResourceCostRequest::setJobId(const std::string &jobId) { + jobId_ = jobId; + setParameter(std::string("JobId"), jobId); +} + +std::string GetLdpsResourceCostRequest::getSecurityToken() const { + return securityToken_; +} + +void GetLdpsResourceCostRequest::setSecurityToken(const std::string &securityToken) { + securityToken_ = securityToken; + setParameter(std::string("SecurityToken"), securityToken); +} + +std::string GetLdpsResourceCostRequest::getRegionId() const { + return regionId_; +} + +void GetLdpsResourceCostRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string GetLdpsResourceCostRequest::getResourceOwnerAccount() const { + return resourceOwnerAccount_; +} + +void GetLdpsResourceCostRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) { + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount); +} + +std::string GetLdpsResourceCostRequest::getOwnerAccount() const { + return ownerAccount_; +} + +void GetLdpsResourceCostRequest::setOwnerAccount(const std::string &ownerAccount) { + ownerAccount_ = ownerAccount; + setParameter(std::string("OwnerAccount"), ownerAccount); +} + +long GetLdpsResourceCostRequest::getEndTime() const { + return endTime_; +} + +void GetLdpsResourceCostRequest::setEndTime(long endTime) { + endTime_ = endTime; + setParameter(std::string("EndTime"), std::to_string(endTime)); +} + +long GetLdpsResourceCostRequest::getOwnerId() const { + return ownerId_; +} + +void GetLdpsResourceCostRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + +std::string GetLdpsResourceCostRequest::getInstanceId() const { + return instanceId_; +} + +void GetLdpsResourceCostRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setParameter(std::string("InstanceId"), instanceId); +} + diff --git a/hitsdb/src/model/GetLdpsResourceCostResult.cc b/hitsdb/src/model/GetLdpsResourceCostResult.cc new file mode 100644 index 000000000..dbb25892e --- /dev/null +++ b/hitsdb/src/model/GetLdpsResourceCostResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Hitsdb; +using namespace AlibabaCloud::Hitsdb::Model; + +GetLdpsResourceCostResult::GetLdpsResourceCostResult() : + ServiceResult() +{} + +GetLdpsResourceCostResult::GetLdpsResourceCostResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetLdpsResourceCostResult::~GetLdpsResourceCostResult() +{} + +void GetLdpsResourceCostResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["InstanceId"].isNull()) + instanceId_ = value["InstanceId"].asString(); + if(!value["JobId"].isNull()) + jobId_ = value["JobId"].asString(); + if(!value["StartTime"].isNull()) + startTime_ = std::stol(value["StartTime"].asString()); + if(!value["EndTime"].isNull()) + endTime_ = std::stol(value["EndTime"].asString()); + if(!value["TotalResource"].isNull()) + totalResource_ = std::stol(value["TotalResource"].asString()); + +} + +long GetLdpsResourceCostResult::getEndTime()const +{ + return endTime_; +} + +std::string GetLdpsResourceCostResult::getInstanceId()const +{ + return instanceId_; +} + +long GetLdpsResourceCostResult::getStartTime()const +{ + return startTime_; +} + +long GetLdpsResourceCostResult::getTotalResource()const +{ + return totalResource_; +} + +std::string GetLdpsResourceCostResult::getJobId()const +{ + return jobId_; +} + diff --git a/hitsdb/src/model/GetLindormInstanceResult.cc b/hitsdb/src/model/GetLindormInstanceResult.cc index e01abe8db..5ddecbd2d 100644 --- a/hitsdb/src/model/GetLindormInstanceResult.cc +++ b/hitsdb/src/model/GetLindormInstanceResult.cc @@ -73,6 +73,8 @@ void GetLindormInstanceResult::parse(const std::string &payload) serviceType_ = value["ServiceType"].asString(); if(!value["EnableKms"].isNull()) enableKms_ = value["EnableKms"].asString() == "true"; + if(!value["EnableML"].isNull()) + enableML_ = value["EnableML"].asString() == "true"; if(!value["DiskUsage"].isNull()) diskUsage_ = value["DiskUsage"].asString(); if(!value["DiskCategory"].isNull()) @@ -117,12 +119,18 @@ void GetLindormInstanceResult::parse(const std::string &payload) enableCompute_ = value["EnableCompute"].asString() == "true"; if(!value["EnableSSL"].isNull()) enableSSL_ = value["EnableSSL"].asString() == "true"; + if(!value["EnableMLCtrl"].isNull()) + enableMLCtrl_ = value["EnableMLCtrl"].asString() == "true"; if(!value["EnableCdc"].isNull()) enableCdc_ = value["EnableCdc"].asString() == "true"; if(!value["EnableStream"].isNull()) enableStream_ = value["EnableStream"].asString() == "true"; + if(!value["EnableLTS"].isNull()) + enableLTS_ = value["EnableLTS"].asString() == "true"; if(!value["EnableShs"].isNull()) enableShs_ = value["EnableShs"].asString() == "true"; + if(!value["EnableBlob"].isNull()) + enableBlob_ = value["EnableBlob"].asString() == "true"; if(!value["MaintainStartTime"].isNull()) maintainStartTime_ = value["MaintainStartTime"].asString(); if(!value["MaintainEndTime"].isNull()) @@ -163,6 +171,10 @@ void GetLindormInstanceResult::parse(const std::string &payload) logNum_ = std::stoi(value["LogNum"].asString()); if(!value["LogSingleStorage"].isNull()) logSingleStorage_ = std::stoi(value["LogSingleStorage"].asString()); + if(!value["ArchVersion"].isNull()) + archVersion_ = value["ArchVersion"].asString(); + if(!value["EnableLsqlVersionV3"].isNull()) + enableLsqlVersionV3_ = value["EnableLsqlVersionV3"].asString() == "true"; } @@ -181,6 +193,11 @@ std::vector GetLindormInstanceResult::getEngin return engineList_; } +bool GetLindormInstanceResult::getEnableLTS()const +{ + return enableLTS_; +} + std::string GetLindormInstanceResult::getResourceGroupId()const { return resourceGroupId_; @@ -301,6 +318,11 @@ bool GetLindormInstanceResult::getEnableCdc()const return enableCdc_; } +bool GetLindormInstanceResult::getEnableMLCtrl()const +{ + return enableMLCtrl_; +} + bool GetLindormInstanceResult::getEnableStream()const { return enableStream_; @@ -321,6 +343,11 @@ std::string GetLindormInstanceResult::getExpireTime()const return expireTime_; } +bool GetLindormInstanceResult::getEnableML()const +{ + return enableML_; +} + int GetLindormInstanceResult::getLogNum()const { return logNum_; @@ -331,11 +358,21 @@ int GetLindormInstanceResult::getLocalCloudStorage()const return localCloudStorage_; } +bool GetLindormInstanceResult::getEnableBlob()const +{ + return enableBlob_; +} + std::string GetLindormInstanceResult::getDiskThreshold()const { return diskThreshold_; } +bool GetLindormInstanceResult::getEnableLsqlVersionV3()const +{ + return enableLsqlVersionV3_; +} + bool GetLindormInstanceResult::getAutoRenew()const { return autoRenew_; @@ -401,6 +438,11 @@ int GetLindormInstanceResult::getCoreNum()const return coreNum_; } +std::string GetLindormInstanceResult::getArchVersion()const +{ + return archVersion_; +} + std::string GetLindormInstanceResult::getCreateTime()const { return createTime_; diff --git a/hitsdb/src/model/ReleaseLindormInstanceRequest.cc b/hitsdb/src/model/ReleaseLindormInstanceRequest.cc index f263cde70..a58c80c9f 100644 --- a/hitsdb/src/model/ReleaseLindormInstanceRequest.cc +++ b/hitsdb/src/model/ReleaseLindormInstanceRequest.cc @@ -34,6 +34,15 @@ void ReleaseLindormInstanceRequest::setResourceOwnerId(long resourceOwnerId) { setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); } +bool ReleaseLindormInstanceRequest::getImmediately() const { + return immediately_; +} + +void ReleaseLindormInstanceRequest::setImmediately(bool immediately) { + immediately_ = immediately; + setParameter(std::string("Immediately"), immediately ? "true" : "false"); +} + std::string ReleaseLindormInstanceRequest::getAccessKeyId() const { return accessKeyId_; } diff --git a/hitsdb/src/model/UpdateInstanceIpWhiteListRequest.cc b/hitsdb/src/model/UpdateInstanceIpWhiteListRequest.cc index 70f04b206..7e5a6935f 100644 --- a/hitsdb/src/model/UpdateInstanceIpWhiteListRequest.cc +++ b/hitsdb/src/model/UpdateInstanceIpWhiteListRequest.cc @@ -34,6 +34,15 @@ void UpdateInstanceIpWhiteListRequest::setResourceOwnerId(long resourceOwnerId) setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); } +bool UpdateInstanceIpWhiteListRequest::get_Delete() const { + return _delete_; +} + +void UpdateInstanceIpWhiteListRequest::set_Delete(bool _delete) { + _delete_ = _delete; + setParameter(std::string("Delete"), _delete ? "true" : "false"); +} + std::string UpdateInstanceIpWhiteListRequest::getAccessKeyId() const { return accessKeyId_; } diff --git a/hitsdb/src/model/UpgradeLindormInstanceRequest.cc b/hitsdb/src/model/UpgradeLindormInstanceRequest.cc index f79bc23b1..db28a5344 100644 --- a/hitsdb/src/model/UpgradeLindormInstanceRequest.cc +++ b/hitsdb/src/model/UpgradeLindormInstanceRequest.cc @@ -34,22 +34,112 @@ void UpgradeLindormInstanceRequest::setResourceOwnerId(long resourceOwnerId) { setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); } -int UpgradeLindormInstanceRequest::getPhoenixCoreNum() const { - return phoenixCoreNum_; +std::string UpgradeLindormInstanceRequest::getLogSpec() const { + return logSpec_; } -void UpgradeLindormInstanceRequest::setPhoenixCoreNum(int phoenixCoreNum) { - phoenixCoreNum_ = phoenixCoreNum; - setParameter(std::string("PhoenixCoreNum"), std::to_string(phoenixCoreNum)); +void UpgradeLindormInstanceRequest::setLogSpec(const std::string &logSpec) { + logSpec_ = logSpec; + setParameter(std::string("LogSpec"), logSpec); } -std::string UpgradeLindormInstanceRequest::getPhoenixCoreSpec() const { - return phoenixCoreSpec_; +std::string UpgradeLindormInstanceRequest::getSecurityToken() const { + return securityToken_; } -void UpgradeLindormInstanceRequest::setPhoenixCoreSpec(const std::string &phoenixCoreSpec) { - phoenixCoreSpec_ = phoenixCoreSpec; - setParameter(std::string("PhoenixCoreSpec"), phoenixCoreSpec); +void UpgradeLindormInstanceRequest::setSecurityToken(const std::string &securityToken) { + securityToken_ = securityToken; + setParameter(std::string("SecurityToken"), securityToken); +} + +int UpgradeLindormInstanceRequest::getTsdbNum() const { + return tsdbNum_; +} + +void UpgradeLindormInstanceRequest::setTsdbNum(int tsdbNum) { + tsdbNum_ = tsdbNum; + setParameter(std::string("TsdbNum"), std::to_string(tsdbNum)); +} + +int UpgradeLindormInstanceRequest::getSolrNum() const { + return solrNum_; +} + +void UpgradeLindormInstanceRequest::setSolrNum(int solrNum) { + solrNum_ = solrNum; + setParameter(std::string("SolrNum"), std::to_string(solrNum)); +} + +long UpgradeLindormInstanceRequest::getOwnerId() const { + return ownerId_; +} + +void UpgradeLindormInstanceRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + +int UpgradeLindormInstanceRequest::getLindormNum() const { + return lindormNum_; +} + +void UpgradeLindormInstanceRequest::setLindormNum(int lindormNum) { + lindormNum_ = lindormNum; + setParameter(std::string("LindormNum"), std::to_string(lindormNum)); +} + +int UpgradeLindormInstanceRequest::getLtsCoreNum() const { + return ltsCoreNum_; +} + +void UpgradeLindormInstanceRequest::setLtsCoreNum(int ltsCoreNum) { + ltsCoreNum_ = ltsCoreNum; + setParameter(std::string("LtsCoreNum"), std::to_string(ltsCoreNum)); +} + +std::string UpgradeLindormInstanceRequest::getInstanceId() const { + return instanceId_; +} + +void UpgradeLindormInstanceRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setParameter(std::string("InstanceId"), instanceId); +} + +int UpgradeLindormInstanceRequest::getMlNum() const { + return mlNum_; +} + +void UpgradeLindormInstanceRequest::setMlNum(int mlNum) { + mlNum_ = mlNum; + setParameter(std::string("MlNum"), std::to_string(mlNum)); +} + +int UpgradeLindormInstanceRequest::getStreamNum() const { + return streamNum_; +} + +void UpgradeLindormInstanceRequest::setStreamNum(int streamNum) { + streamNum_ = streamNum; + setParameter(std::string("StreamNum"), std::to_string(streamNum)); +} + +int UpgradeLindormInstanceRequest::getLogSingleStorage() const { + return logSingleStorage_; +} + +void UpgradeLindormInstanceRequest::setLogSingleStorage(int logSingleStorage) { + logSingleStorage_ = logSingleStorage; + setParameter(std::string("LogSingleStorage"), std::to_string(logSingleStorage)); +} + +std::string UpgradeLindormInstanceRequest::getZoneId() const { + return zoneId_; +} + +void UpgradeLindormInstanceRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setParameter(std::string("ZoneId"), zoneId); } std::string UpgradeLindormInstanceRequest::getClientToken() const { @@ -97,24 +187,6 @@ void UpgradeLindormInstanceRequest::setAccessKeyId(const std::string &accessKeyI setParameter(std::string("AccessKeyId"), accessKeyId); } -std::string UpgradeLindormInstanceRequest::getLogSpec() const { - return logSpec_; -} - -void UpgradeLindormInstanceRequest::setLogSpec(const std::string &logSpec) { - logSpec_ = logSpec; - setParameter(std::string("LogSpec"), logSpec); -} - -std::string UpgradeLindormInstanceRequest::getSecurityToken() const { - return securityToken_; -} - -void UpgradeLindormInstanceRequest::setSecurityToken(const std::string &securityToken) { - securityToken_ = securityToken; - setParameter(std::string("SecurityToken"), securityToken); -} - std::string UpgradeLindormInstanceRequest::getRegionId() const { return regionId_; } @@ -124,15 +196,6 @@ void UpgradeLindormInstanceRequest::setRegionId(const std::string ®ionId) { setParameter(std::string("RegionId"), regionId); } -int UpgradeLindormInstanceRequest::getTsdbNum() const { - return tsdbNum_; -} - -void UpgradeLindormInstanceRequest::setTsdbNum(int tsdbNum) { - tsdbNum_ = tsdbNum; - setParameter(std::string("TsdbNum"), std::to_string(tsdbNum)); -} - std::string UpgradeLindormInstanceRequest::getLindormSpec() const { return lindormSpec_; } @@ -142,15 +205,6 @@ void UpgradeLindormInstanceRequest::setLindormSpec(const std::string &lindormSpe setParameter(std::string("LindormSpec"), lindormSpec); } -int UpgradeLindormInstanceRequest::getSolrNum() const { - return solrNum_; -} - -void UpgradeLindormInstanceRequest::setSolrNum(int solrNum) { - solrNum_ = solrNum; - setParameter(std::string("SolrNum"), std::to_string(solrNum)); -} - int UpgradeLindormInstanceRequest::getColdStorage() const { return coldStorage_; } @@ -214,40 +268,22 @@ void UpgradeLindormInstanceRequest::setFilestoreNum(int filestoreNum) { setParameter(std::string("FilestoreNum"), std::to_string(filestoreNum)); } -long UpgradeLindormInstanceRequest::getOwnerId() const { - return ownerId_; +std::string UpgradeLindormInstanceRequest::getStreamSpec() const { + return streamSpec_; } -void UpgradeLindormInstanceRequest::setOwnerId(long ownerId) { - ownerId_ = ownerId; - setParameter(std::string("OwnerId"), std::to_string(ownerId)); +void UpgradeLindormInstanceRequest::setStreamSpec(const std::string &streamSpec) { + streamSpec_ = streamSpec; + setParameter(std::string("StreamSpec"), streamSpec); } -int UpgradeLindormInstanceRequest::getLindormNum() const { - return lindormNum_; +std::string UpgradeLindormInstanceRequest::getMlSpec() const { + return mlSpec_; } -void UpgradeLindormInstanceRequest::setLindormNum(int lindormNum) { - lindormNum_ = lindormNum; - setParameter(std::string("LindormNum"), std::to_string(lindormNum)); -} - -int UpgradeLindormInstanceRequest::getLtsCoreNum() const { - return ltsCoreNum_; -} - -void UpgradeLindormInstanceRequest::setLtsCoreNum(int ltsCoreNum) { - ltsCoreNum_ = ltsCoreNum; - setParameter(std::string("LtsCoreNum"), std::to_string(ltsCoreNum)); -} - -std::string UpgradeLindormInstanceRequest::getInstanceId() const { - return instanceId_; -} - -void UpgradeLindormInstanceRequest::setInstanceId(const std::string &instanceId) { - instanceId_ = instanceId; - setParameter(std::string("InstanceId"), instanceId); +void UpgradeLindormInstanceRequest::setMlSpec(const std::string &mlSpec) { + mlSpec_ = mlSpec; + setParameter(std::string("MlSpec"), mlSpec); } std::string UpgradeLindormInstanceRequest::getLtsCoreSpec() const { @@ -268,21 +304,3 @@ void UpgradeLindormInstanceRequest::setClusterStorage(int clusterStorage) { setParameter(std::string("ClusterStorage"), std::to_string(clusterStorage)); } -int UpgradeLindormInstanceRequest::getLogSingleStorage() const { - return logSingleStorage_; -} - -void UpgradeLindormInstanceRequest::setLogSingleStorage(int logSingleStorage) { - logSingleStorage_ = logSingleStorage; - setParameter(std::string("LogSingleStorage"), std::to_string(logSingleStorage)); -} - -std::string UpgradeLindormInstanceRequest::getZoneId() const { - return zoneId_; -} - -void UpgradeLindormInstanceRequest::setZoneId(const std::string &zoneId) { - zoneId_ = zoneId; - setParameter(std::string("ZoneId"), zoneId); -} -