diff --git a/VERSION b/VERSION index e902d6f9a..e0aa1cecc 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1826 \ No newline at end of file +1.36.1827 \ No newline at end of file diff --git a/oceanbasepro/CMakeLists.txt b/oceanbasepro/CMakeLists.txt index 45e2d2ed7..a667366f2 100644 --- a/oceanbasepro/CMakeLists.txt +++ b/oceanbasepro/CMakeLists.txt @@ -69,6 +69,10 @@ set(oceanbasepro_public_header_model include/alibabacloud/oceanbasepro/model/DescribeAvailableCpuResourceResult.h include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceRequest.h include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceResult.h + include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecRequest.h + include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h + include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneRequest.h + include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneResult.h include/alibabacloud/oceanbasepro/model/DescribeCharsetRequest.h include/alibabacloud/oceanbasepro/model/DescribeCharsetResult.h include/alibabacloud/oceanbasepro/model/DescribeDatabasesRequest.h @@ -143,6 +147,8 @@ set(oceanbasepro_public_header_model include/alibabacloud/oceanbasepro/model/DescribeSlowSQLListResult.h include/alibabacloud/oceanbasepro/model/DescribeTenantRequest.h include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h + include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionRequest.h + include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionResult.h include/alibabacloud/oceanbasepro/model/DescribeTenantMetricsRequest.h include/alibabacloud/oceanbasepro/model/DescribeTenantMetricsResult.h include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsRequest.h @@ -191,6 +197,8 @@ set(oceanbasepro_public_header_model include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecResult.h include/alibabacloud/oceanbasepro/model/ModifyInstanceTagsRequest.h include/alibabacloud/oceanbasepro/model/ModifyInstanceTagsResult.h + include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h + include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityResult.h include/alibabacloud/oceanbasepro/model/ModifyParametersRequest.h include/alibabacloud/oceanbasepro/model/ModifyParametersResult.h include/alibabacloud/oceanbasepro/model/ModifySecurityIpsRequest.h @@ -292,6 +300,10 @@ set(oceanbasepro_src src/model/DescribeAvailableCpuResourceResult.cc src/model/DescribeAvailableMemResourceRequest.cc src/model/DescribeAvailableMemResourceResult.cc + src/model/DescribeAvailableSpecRequest.cc + src/model/DescribeAvailableSpecResult.cc + src/model/DescribeAvailableZoneRequest.cc + src/model/DescribeAvailableZoneResult.cc src/model/DescribeCharsetRequest.cc src/model/DescribeCharsetResult.cc src/model/DescribeDatabasesRequest.cc @@ -366,6 +378,8 @@ set(oceanbasepro_src src/model/DescribeSlowSQLListResult.cc src/model/DescribeTenantRequest.cc src/model/DescribeTenantResult.cc + src/model/DescribeTenantEncryptionRequest.cc + src/model/DescribeTenantEncryptionResult.cc src/model/DescribeTenantMetricsRequest.cc src/model/DescribeTenantMetricsResult.cc src/model/DescribeTenantSecurityConfigsRequest.cc @@ -414,6 +428,8 @@ set(oceanbasepro_src src/model/ModifyInstanceSpecResult.cc src/model/ModifyInstanceTagsRequest.cc src/model/ModifyInstanceTagsResult.cc + src/model/ModifyInstanceTemporaryCapacityRequest.cc + src/model/ModifyInstanceTemporaryCapacityResult.cc src/model/ModifyParametersRequest.cc src/model/ModifyParametersResult.cc src/model/ModifySecurityIpsRequest.cc diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h b/oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h index 3ead00922..e6f248d15 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h @@ -70,6 +70,10 @@ #include "model/DescribeAvailableCpuResourceResult.h" #include "model/DescribeAvailableMemResourceRequest.h" #include "model/DescribeAvailableMemResourceResult.h" +#include "model/DescribeAvailableSpecRequest.h" +#include "model/DescribeAvailableSpecResult.h" +#include "model/DescribeAvailableZoneRequest.h" +#include "model/DescribeAvailableZoneResult.h" #include "model/DescribeCharsetRequest.h" #include "model/DescribeCharsetResult.h" #include "model/DescribeDatabasesRequest.h" @@ -144,6 +148,8 @@ #include "model/DescribeSlowSQLListResult.h" #include "model/DescribeTenantRequest.h" #include "model/DescribeTenantResult.h" +#include "model/DescribeTenantEncryptionRequest.h" +#include "model/DescribeTenantEncryptionResult.h" #include "model/DescribeTenantMetricsRequest.h" #include "model/DescribeTenantMetricsResult.h" #include "model/DescribeTenantSecurityConfigsRequest.h" @@ -192,6 +198,8 @@ #include "model/ModifyInstanceSpecResult.h" #include "model/ModifyInstanceTagsRequest.h" #include "model/ModifyInstanceTagsResult.h" +#include "model/ModifyInstanceTemporaryCapacityRequest.h" +#include "model/ModifyInstanceTemporaryCapacityResult.h" #include "model/ModifyParametersRequest.h" #include "model/ModifyParametersResult.h" #include "model/ModifySecurityIpsRequest.h" @@ -323,6 +331,12 @@ namespace AlibabaCloud typedef Outcome DescribeAvailableMemResourceOutcome; typedef std::future DescribeAvailableMemResourceOutcomeCallable; typedef std::function&)> DescribeAvailableMemResourceAsyncHandler; + typedef Outcome DescribeAvailableSpecOutcome; + typedef std::future DescribeAvailableSpecOutcomeCallable; + typedef std::function&)> DescribeAvailableSpecAsyncHandler; + typedef Outcome DescribeAvailableZoneOutcome; + typedef std::future DescribeAvailableZoneOutcomeCallable; + typedef std::function&)> DescribeAvailableZoneAsyncHandler; typedef Outcome DescribeCharsetOutcome; typedef std::future DescribeCharsetOutcomeCallable; typedef std::function&)> DescribeCharsetAsyncHandler; @@ -434,6 +448,9 @@ namespace AlibabaCloud typedef Outcome DescribeTenantOutcome; typedef std::future DescribeTenantOutcomeCallable; typedef std::function&)> DescribeTenantAsyncHandler; + typedef Outcome DescribeTenantEncryptionOutcome; + typedef std::future DescribeTenantEncryptionOutcomeCallable; + typedef std::function&)> DescribeTenantEncryptionAsyncHandler; typedef Outcome DescribeTenantMetricsOutcome; typedef std::future DescribeTenantMetricsOutcomeCallable; typedef std::function&)> DescribeTenantMetricsAsyncHandler; @@ -506,6 +523,9 @@ namespace AlibabaCloud typedef Outcome ModifyInstanceTagsOutcome; typedef std::future ModifyInstanceTagsOutcomeCallable; typedef std::function&)> ModifyInstanceTagsAsyncHandler; + typedef Outcome ModifyInstanceTemporaryCapacityOutcome; + typedef std::future ModifyInstanceTemporaryCapacityOutcomeCallable; + typedef std::function&)> ModifyInstanceTemporaryCapacityAsyncHandler; typedef Outcome ModifyParametersOutcome; typedef std::future ModifyParametersOutcomeCallable; typedef std::function&)> ModifyParametersAsyncHandler; @@ -658,6 +678,12 @@ namespace AlibabaCloud DescribeAvailableMemResourceOutcome describeAvailableMemResource(const Model::DescribeAvailableMemResourceRequest &request)const; void describeAvailableMemResourceAsync(const Model::DescribeAvailableMemResourceRequest& request, const DescribeAvailableMemResourceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeAvailableMemResourceOutcomeCallable describeAvailableMemResourceCallable(const Model::DescribeAvailableMemResourceRequest& request) const; + DescribeAvailableSpecOutcome describeAvailableSpec(const Model::DescribeAvailableSpecRequest &request)const; + void describeAvailableSpecAsync(const Model::DescribeAvailableSpecRequest& request, const DescribeAvailableSpecAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeAvailableSpecOutcomeCallable describeAvailableSpecCallable(const Model::DescribeAvailableSpecRequest& request) const; + DescribeAvailableZoneOutcome describeAvailableZone(const Model::DescribeAvailableZoneRequest &request)const; + void describeAvailableZoneAsync(const Model::DescribeAvailableZoneRequest& request, const DescribeAvailableZoneAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeAvailableZoneOutcomeCallable describeAvailableZoneCallable(const Model::DescribeAvailableZoneRequest& request) const; DescribeCharsetOutcome describeCharset(const Model::DescribeCharsetRequest &request)const; void describeCharsetAsync(const Model::DescribeCharsetRequest& request, const DescribeCharsetAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeCharsetOutcomeCallable describeCharsetCallable(const Model::DescribeCharsetRequest& request) const; @@ -769,6 +795,9 @@ namespace AlibabaCloud DescribeTenantOutcome describeTenant(const Model::DescribeTenantRequest &request)const; void describeTenantAsync(const Model::DescribeTenantRequest& request, const DescribeTenantAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeTenantOutcomeCallable describeTenantCallable(const Model::DescribeTenantRequest& request) const; + DescribeTenantEncryptionOutcome describeTenantEncryption(const Model::DescribeTenantEncryptionRequest &request)const; + void describeTenantEncryptionAsync(const Model::DescribeTenantEncryptionRequest& request, const DescribeTenantEncryptionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeTenantEncryptionOutcomeCallable describeTenantEncryptionCallable(const Model::DescribeTenantEncryptionRequest& request) const; DescribeTenantMetricsOutcome describeTenantMetrics(const Model::DescribeTenantMetricsRequest &request)const; void describeTenantMetricsAsync(const Model::DescribeTenantMetricsRequest& request, const DescribeTenantMetricsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeTenantMetricsOutcomeCallable describeTenantMetricsCallable(const Model::DescribeTenantMetricsRequest& request) const; @@ -841,6 +870,9 @@ namespace AlibabaCloud ModifyInstanceTagsOutcome modifyInstanceTags(const Model::ModifyInstanceTagsRequest &request)const; void modifyInstanceTagsAsync(const Model::ModifyInstanceTagsRequest& request, const ModifyInstanceTagsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ModifyInstanceTagsOutcomeCallable modifyInstanceTagsCallable(const Model::ModifyInstanceTagsRequest& request) const; + ModifyInstanceTemporaryCapacityOutcome modifyInstanceTemporaryCapacity(const Model::ModifyInstanceTemporaryCapacityRequest &request)const; + void modifyInstanceTemporaryCapacityAsync(const Model::ModifyInstanceTemporaryCapacityRequest& request, const ModifyInstanceTemporaryCapacityAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyInstanceTemporaryCapacityOutcomeCallable modifyInstanceTemporaryCapacityCallable(const Model::ModifyInstanceTemporaryCapacityRequest& request) const; ModifyParametersOutcome modifyParameters(const Model::ModifyParametersRequest &request)const; void modifyParametersAsync(const Model::ModifyParametersRequest& request, const ModifyParametersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ModifyParametersOutcomeCallable modifyParametersCallable(const Model::ModifyParametersRequest& request) const; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h index 15d7ffed4..ca222deaa 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h @@ -30,6 +30,8 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT CreateInstanceRequest : public RpcService public: CreateInstanceRequest(); ~CreateInstanceRequest(); + std::string getIsolationOptimization() const; + void setIsolationOptimization(const std::string &isolationOptimization); std::string getInstanceClass() const; void setInstanceClass(const std::string &instanceClass); std::string getResourceGroupId() const; @@ -38,6 +40,8 @@ public: void setAutoRenewPeriod(long autoRenewPeriod); long getPeriod() const; void setPeriod(long period); + bool getDryRun() const; + void setDryRun(bool dryRun); long getDiskSize() const; void setDiskSize(long diskSize); std::string getZones() const; @@ -50,6 +54,8 @@ public: void setPeriodUnit(const std::string &periodUnit); std::string getInstanceName() const; void setInstanceName(const std::string &instanceName); + std::string getReplicaMode() const; + void setReplicaMode(const std::string &replicaMode); bool getAutoRenew() const; void setAutoRenew(bool autoRenew); std::string getSeries() const; @@ -60,16 +66,19 @@ public: void setBid(const std::string &bid); private: + std::string isolationOptimization_; std::string instanceClass_; std::string resourceGroupId_; long autoRenewPeriod_; long period_; + bool dryRun_; long diskSize_; std::string zones_; std::string diskType_; std::string obVersion_; std::string periodUnit_; std::string instanceName_; + std::string replicaMode_; bool autoRenew_; std::string series_; std::string chargeType_; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceResult.h index a6ca61203..9a9c70709 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceResult.h @@ -37,6 +37,7 @@ namespace AlibabaCloud std::string resourceGroupId; std::string instanceId; std::string orderId; + bool dryRunResult; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantRequest.h index bc5831e8b..2add2ca1b 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantRequest.h @@ -36,6 +36,8 @@ public: void setTenantMode(const std::string &tenantMode); int getMemory() const; void setMemory(int memory); + long getLogDisk() const; + void setLogDisk(long logDisk); std::string getTimeZone() const; void setTimeZone(const std::string &timeZone); std::string getDescription() const; @@ -54,11 +56,14 @@ public: void setPrimaryZone(const std::string &primaryZone); std::string getTenantName() const; void setTenantName(const std::string &tenantName); + std::string getReadOnlyZoneList() const; + void setReadOnlyZoneList(const std::string &readOnlyZoneList); private: std::string charset_; std::string tenantMode_; int memory_; + long logDisk_; std::string timeZone_; std::string description_; std::string userVSwitchId_; @@ -68,6 +73,7 @@ private: std::string instanceId_; std::string primaryZone_; std::string tenantName_; + std::string readOnlyZoneList_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesRequest.h index 51e0ac6f6..f511fbe35 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesRequest.h @@ -32,11 +32,14 @@ public: ~DeleteInstancesRequest(); std::string getBackupRetainMode() const; void setBackupRetainMode(const std::string &backupRetainMode); + bool getDryRun() const; + void setDryRun(bool dryRun); std::string getInstanceIds() const; void setInstanceIds(const std::string &instanceIds); private: std::string backupRetainMode_; + bool dryRun_; std::string instanceIds_; }; } // namespace Model diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesResult.h index eedeb3683..25d8b7c73 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesResult.h @@ -32,15 +32,21 @@ namespace AlibabaCloud class ALIBABACLOUD_OCEANBASEPRO_EXPORT DeleteInstancesResult : public ServiceResult { public: + struct Data + { + bool dryRunResult; + }; DeleteInstancesResult(); explicit DeleteInstancesResult(const std::string &payload); ~DeleteInstancesResult(); + Data getData()const; protected: void parse(const std::string &payload); private: + Data data_; }; } diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceResult.h index 4342d9945..8af5fd142 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceResult.h @@ -37,6 +37,7 @@ namespace AlibabaCloud long maxMem; long usedMem; long minMem; + std::string safeMem; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecRequest.h new file mode 100644 index 000000000..e65a581e6 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecRequest.h @@ -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_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeAvailableSpecRequest : public RpcServiceRequest { +public: + DescribeAvailableSpecRequest(); + ~DescribeAvailableSpecRequest(); + std::string getUpgradeType() const; + void setUpgradeType(const std::string &upgradeType); + std::string getSpec() const; + void setSpec(const std::string &spec); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + +private: + std::string upgradeType_; + std::string spec_; + std::string instanceId_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h new file mode 100644 index 000000000..710e63259 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h @@ -0,0 +1,75 @@ +/* + * 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_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECRESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeAvailableSpecResult : public ServiceResult + { + public: + struct Data + { + struct AvailableSpecificationsItem + { + struct DiskSizeRange + { + long min; + long max; + long step; + }; + struct LogDiskSizeRange + { + long min; + long max; + long step; + }; + std::vector nodeNum; + DiskSizeRange diskSizeRange; + std::string instanceClass; + std::string spec; + LogDiskSizeRange logDiskSizeRange; + }; + std::vector availableSpecifications; + }; + + + DescribeAvailableSpecResult(); + explicit DescribeAvailableSpecResult(const std::string &payload); + ~DescribeAvailableSpecResult(); + Data getData()const; + + protected: + void parse(const std::string &payload); + private: + Data data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECRESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneRequest.h new file mode 100644 index 000000000..4b89835fd --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONEREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeAvailableZoneRequest : public RpcServiceRequest { +public: + DescribeAvailableZoneRequest(); + ~DescribeAvailableZoneRequest(); + std::string getSpec() const; + void setSpec(const std::string &spec); + std::string getObVersion() const; + void setObVersion(const std::string &obVersion); + std::string getSeries() const; + void setSeries(const std::string &series); + std::string getInstanceType() const; + void setInstanceType(const std::string &instanceType); + std::string getDeployType() const; + void setDeployType(const std::string &deployType); + +private: + std::string spec_; + std::string obVersion_; + std::string series_; + std::string instanceType_; + std::string deployType_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONEREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneResult.h new file mode 100644 index 000000000..2d9a04494 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneResult.h @@ -0,0 +1,85 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONERESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeAvailableZoneResult : public ServiceResult + { + public: + struct Data + { + struct AvailableZonesItem + { + struct SupportSpecificationsItem + { + struct DiskSizeRange + { + long min; + long max; + long step; + }; + struct SupportEngineVersionsItem + { + std::vector supportReplicaModes; + std::string obVersion; + bool supportIsolationOptimization; + }; + DiskSizeRange diskSizeRange; + std::vector diskTypes; + std::vector supportEngineVersions; + std::string instanceClass; + std::string spec; + }; + std::string deployType; + std::string series; + std::vector supportSpecifications; + std::string channel; + std::string region; + std::string instanceType; + std::string zones; + }; + std::vector availableZones; + }; + + + DescribeAvailableZoneResult(); + explicit DescribeAvailableZoneResult(const std::string &payload); + ~DescribeAvailableZoneResult(); + Data getData()const; + + protected: + void parse(const std::string &payload); + private: + Data data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONERESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesRequest.h index e69d51300..6beb7b50c 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesRequest.h @@ -34,6 +34,8 @@ public: void setSearchKey(const std::string &searchKey); int getPageNumber() const; void setPageNumber(int pageNumber); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); std::string getDatabaseName() const; void setDatabaseName(const std::string &databaseName); bool getWithTables() const; @@ -46,6 +48,7 @@ public: private: std::string searchKey_; int pageNumber_; + std::string instanceId_; std::string databaseName_; bool withTables_; std::string tenantId_; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesResult.h index aecaeaaff..9abe2bc0f 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesResult.h @@ -48,6 +48,7 @@ namespace AlibabaCloud std::string status; std::string description; std::string instanceId; + std::string tenantName; std::string createTime; std::string databaseName; std::string encoding; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h index 55c4f9548..0fb86ba07 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h @@ -63,6 +63,9 @@ namespace AlibabaCloud }; struct LogDiskSize { + std::string maxLogAssignedPercent; + std::string logAssignedSize; + std::vector maxLogAssignedObServer; long unitDiskSize; long totalDiskSize; }; @@ -95,17 +98,20 @@ namespace AlibabaCloud bool autoScale; }; std::string deployType; + std::string proxyServiceStatus; std::string nodeNum; bool enableIsolationOptimization; std::string dataMergeTime; bool inTempCapacityStatus; bool isTrustEcs; + std::string proxyClusterId; bool isLatestObVersion; std::vector availableZones; std::vector zones; std::string diskType; std::string deployMode; std::string version; + std::string cpuArchitecture; bool isolationOptimization; std::string instanceRole; std::string maintainTime; @@ -119,6 +125,7 @@ namespace AlibabaCloud std::string instanceClass; std::string payType; bool dataDiskAutoScale; + bool enableProxyService; std::string instanceName; std::string series; DataDiskAutoScaleConfig dataDiskAutoScaleConfig; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsRequest.h index 5831eb9ad..5d47540c5 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsRequest.h @@ -32,9 +32,12 @@ public: ~DescribeInstanceSecurityConfigsRequest(); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); + std::string getCheckId() const; + void setCheckId(const std::string &checkId); private: std::string instanceId_; + std::string checkId_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsResult.h index 436a67494..c569542a7 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsResult.h @@ -43,6 +43,9 @@ namespace AlibabaCloud std::string configGroup; }; std::vector securityConfigs; + std::string checkTime; + std::string checkId; + std::string instanceId; int totalCheckCount; int totalRiskCount; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h index 8ebe5cc96..217cadf47 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h @@ -88,6 +88,7 @@ namespace AlibabaCloud std::vector availableZones; std::string diskType; std::string deployMode; + std::string cpuArchitecture; std::string version; std::string commodityCode; std::string diskSize; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLSamplesResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLSamplesResult.h index 687c2cee3..70dc231cc 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLSamplesResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLSamplesResult.h @@ -48,7 +48,7 @@ namespace AlibabaCloud std::string sqlType; double queueTime; double blockIndexCacheHit; - double tableScan; + bool tableScan; double waitCount; std::string requestId; std::string requestTime; @@ -65,9 +65,9 @@ namespace AlibabaCloud double memstoreReadRows; double getPlanTime; double elapsedTime; - double hitPlan; + bool hitPlan; double returnRows; - double executorRpc; + bool executorRpc; double blockCacheHit; std::string dbName; double netWaitTime; @@ -75,6 +75,7 @@ namespace AlibabaCloud std::string userName; double netTime; double rpcCount; + std::string fullSqlText; std::string statement; double planId; double rowCacheHit; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionRequest.h new file mode 100644 index 000000000..d2c2615c9 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeTenantEncryptionRequest : public RpcServiceRequest { +public: + DescribeTenantEncryptionRequest(); + ~DescribeTenantEncryptionRequest(); + long getPageNumber() const; + void setPageNumber(long pageNumber); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + std::string getTenantId() const; + void setTenantId(const std::string &tenantId); + long getPageSize() const; + void setPageSize(long pageSize); + std::string getTenantName() const; + void setTenantName(const std::string &tenantName); + +private: + long pageNumber_; + std::string instanceId_; + std::string tenantId_; + long pageSize_; + std::string tenantName_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionResult.h new file mode 100644 index 000000000..2c847daf4 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONRESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeTenantEncryptionResult : public ServiceResult + { + public: + struct TenantEncryptionsItem + { + std::string status; + std::string encryptionType; + std::string tenantId; + std::string tenantStatus; + std::string tenantName; + bool enableEncryption; + std::string tenantMode; + std::string encryptionKeyId; + }; + + + DescribeTenantEncryptionResult(); + explicit DescribeTenantEncryptionResult(const std::string &payload); + ~DescribeTenantEncryptionResult(); + int getTotalCount()const; + std::vector getTenantEncryptions()const; + + protected: + void parse(const std::string &payload); + private: + int totalCount_; + std::vector tenantEncryptions_; + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONRESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h index 5be22ac7d..fb555a12f 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h @@ -58,11 +58,17 @@ namespace AlibabaCloud int maxCapacityUnit; int minCapacityUnit; }; + struct LogDiskSize + { + int totalLogDisk; + int unitLogDisk; + }; CapacityUnit capacityUnit; Memory memory; int unitNum; DiskSize diskSize; Cpu cpu; + LogDiskSize logDiskSize; }; struct TenantConnectionsItem { @@ -71,6 +77,7 @@ namespace AlibabaCloud std::string internetAddress; std::string intranetAddressSlaveZoneId; std::string internetAddressStatus; + long maxConnectionNum; std::string vSwitchId; std::string tenantEndpointId; std::string intranetAddressMasterZoneId; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsRequest.h index e15375cb6..14de0d5eb 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsRequest.h @@ -34,10 +34,13 @@ public: void setInstanceId(const std::string &instanceId); std::string getTenantId() const; void setTenantId(const std::string &tenantId); + std::string getCheckId() const; + void setCheckId(const std::string &checkId); private: std::string instanceId_; std::string tenantId_; + std::string checkId_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsResult.h index 9fa4a9393..9079dc558 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsResult.h @@ -49,6 +49,9 @@ namespace AlibabaCloud std::string tenantName; int riskCount; }; + std::string checkTime; + std::string checkId; + std::string instanceId; int totalCheckCount; std::vector tenantSecurityConfigs; int totalRiskCount; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumRequest.h index 48bf9361c..9f222cc0a 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumRequest.h @@ -30,12 +30,15 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyInstanceNodeNumRequest : public Rpc public: ModifyInstanceNodeNumRequest(); ~ModifyInstanceNodeNumRequest(); + bool getDryRun() const; + void setDryRun(bool dryRun); std::string getNodeNum() const; void setNodeNum(const std::string &nodeNum); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); private: + bool dryRun_; std::string nodeNum_; std::string instanceId_; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumResult.h index bdb6032df..f03671a4f 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumResult.h @@ -35,6 +35,7 @@ namespace AlibabaCloud struct Data { std::string orderId; + bool dryRunResult; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h index 321860d9e..82c8ea84d 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h @@ -34,6 +34,8 @@ public: void setAutoUseCoupon(bool autoUseCoupon); std::string getInstanceClass() const; void setInstanceClass(const std::string &instanceClass); + bool getDryRun() const; + void setDryRun(bool dryRun); long getDiskSize() const; void setDiskSize(long diskSize); std::string getInstanceId() const; @@ -44,6 +46,7 @@ public: private: bool autoUseCoupon_; std::string instanceClass_; + bool dryRun_; long diskSize_; std::string instanceId_; long logDiskSize_; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecResult.h index 0170bf4dc..ea388e240 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecResult.h @@ -35,6 +35,7 @@ namespace AlibabaCloud struct Data { std::string orderId; + bool dryRunResult; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h new file mode 100644 index 000000000..8caee2fce --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h @@ -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_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyInstanceTemporaryCapacityRequest : public RpcServiceRequest { +public: + ModifyInstanceTemporaryCapacityRequest(); + ~ModifyInstanceTemporaryCapacityRequest(); + std::string getDiskSize() const; + void setDiskSize(const std::string &diskSize); + std::string getSpec() const; + void setSpec(const std::string &spec); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + +private: + std::string diskSize_; + std::string spec_; + std::string instanceId_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityResult.h new file mode 100644 index 000000000..4d6355960 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityResult.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_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYRESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyInstanceTemporaryCapacityResult : public ServiceResult + { + public: + + + ModifyInstanceTemporaryCapacityResult(); + explicit ModifyInstanceTemporaryCapacityResult(const std::string &payload); + ~ModifyInstanceTemporaryCapacityResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYRESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantResourceRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantResourceRequest.h index 9a2140a7a..557cf8c6a 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantResourceRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantResourceRequest.h @@ -32,18 +32,24 @@ public: ~ModifyTenantResourceRequest(); int getMemory() const; void setMemory(int memory); + long getLogDisk() const; + void setLogDisk(long logDisk); int getCpu() const; void setCpu(int cpu); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); std::string getTenantId() const; void setTenantId(const std::string &tenantId); + std::string getReadOnlyZoneList() const; + void setReadOnlyZoneList(const std::string &readOnlyZoneList); private: int memory_; + long logDisk_; int cpu_; std::string instanceId_; std::string tenantId_; + std::string readOnlyZoneList_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/src/OceanBaseProClient.cc b/oceanbasepro/src/OceanBaseProClient.cc index c1863341b..620f20d45 100644 --- a/oceanbasepro/src/OceanBaseProClient.cc +++ b/oceanbasepro/src/OceanBaseProClient.cc @@ -915,6 +915,78 @@ OceanBaseProClient::DescribeAvailableMemResourceOutcomeCallable OceanBaseProClie return task->get_future(); } +OceanBaseProClient::DescribeAvailableSpecOutcome OceanBaseProClient::describeAvailableSpec(const DescribeAvailableSpecRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeAvailableSpecOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeAvailableSpecOutcome(DescribeAvailableSpecResult(outcome.result())); + else + return DescribeAvailableSpecOutcome(outcome.error()); +} + +void OceanBaseProClient::describeAvailableSpecAsync(const DescribeAvailableSpecRequest& request, const DescribeAvailableSpecAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeAvailableSpec(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::DescribeAvailableSpecOutcomeCallable OceanBaseProClient::describeAvailableSpecCallable(const DescribeAvailableSpecRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeAvailableSpec(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +OceanBaseProClient::DescribeAvailableZoneOutcome OceanBaseProClient::describeAvailableZone(const DescribeAvailableZoneRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeAvailableZoneOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeAvailableZoneOutcome(DescribeAvailableZoneResult(outcome.result())); + else + return DescribeAvailableZoneOutcome(outcome.error()); +} + +void OceanBaseProClient::describeAvailableZoneAsync(const DescribeAvailableZoneRequest& request, const DescribeAvailableZoneAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeAvailableZone(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::DescribeAvailableZoneOutcomeCallable OceanBaseProClient::describeAvailableZoneCallable(const DescribeAvailableZoneRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeAvailableZone(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + OceanBaseProClient::DescribeCharsetOutcome OceanBaseProClient::describeCharset(const DescribeCharsetRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2247,6 +2319,42 @@ OceanBaseProClient::DescribeTenantOutcomeCallable OceanBaseProClient::describeTe return task->get_future(); } +OceanBaseProClient::DescribeTenantEncryptionOutcome OceanBaseProClient::describeTenantEncryption(const DescribeTenantEncryptionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeTenantEncryptionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeTenantEncryptionOutcome(DescribeTenantEncryptionResult(outcome.result())); + else + return DescribeTenantEncryptionOutcome(outcome.error()); +} + +void OceanBaseProClient::describeTenantEncryptionAsync(const DescribeTenantEncryptionRequest& request, const DescribeTenantEncryptionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeTenantEncryption(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::DescribeTenantEncryptionOutcomeCallable OceanBaseProClient::describeTenantEncryptionCallable(const DescribeTenantEncryptionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeTenantEncryption(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + OceanBaseProClient::DescribeTenantMetricsOutcome OceanBaseProClient::describeTenantMetrics(const DescribeTenantMetricsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -3111,6 +3219,42 @@ OceanBaseProClient::ModifyInstanceTagsOutcomeCallable OceanBaseProClient::modify return task->get_future(); } +OceanBaseProClient::ModifyInstanceTemporaryCapacityOutcome OceanBaseProClient::modifyInstanceTemporaryCapacity(const ModifyInstanceTemporaryCapacityRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyInstanceTemporaryCapacityOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyInstanceTemporaryCapacityOutcome(ModifyInstanceTemporaryCapacityResult(outcome.result())); + else + return ModifyInstanceTemporaryCapacityOutcome(outcome.error()); +} + +void OceanBaseProClient::modifyInstanceTemporaryCapacityAsync(const ModifyInstanceTemporaryCapacityRequest& request, const ModifyInstanceTemporaryCapacityAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyInstanceTemporaryCapacity(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::ModifyInstanceTemporaryCapacityOutcomeCallable OceanBaseProClient::modifyInstanceTemporaryCapacityCallable(const ModifyInstanceTemporaryCapacityRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyInstanceTemporaryCapacity(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + OceanBaseProClient::ModifyParametersOutcome OceanBaseProClient::modifyParameters(const ModifyParametersRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/oceanbasepro/src/model/CreateInstanceRequest.cc b/oceanbasepro/src/model/CreateInstanceRequest.cc index 15edc68ea..110391cf3 100644 --- a/oceanbasepro/src/model/CreateInstanceRequest.cc +++ b/oceanbasepro/src/model/CreateInstanceRequest.cc @@ -25,6 +25,15 @@ CreateInstanceRequest::CreateInstanceRequest() CreateInstanceRequest::~CreateInstanceRequest() {} +std::string CreateInstanceRequest::getIsolationOptimization() const { + return isolationOptimization_; +} + +void CreateInstanceRequest::setIsolationOptimization(const std::string &isolationOptimization) { + isolationOptimization_ = isolationOptimization; + setBodyParameter(std::string("IsolationOptimization"), isolationOptimization); +} + std::string CreateInstanceRequest::getInstanceClass() const { return instanceClass_; } @@ -61,6 +70,15 @@ void CreateInstanceRequest::setPeriod(long period) { setBodyParameter(std::string("Period"), std::to_string(period)); } +bool CreateInstanceRequest::getDryRun() const { + return dryRun_; +} + +void CreateInstanceRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + long CreateInstanceRequest::getDiskSize() const { return diskSize_; } @@ -115,6 +133,15 @@ void CreateInstanceRequest::setInstanceName(const std::string &instanceName) { setBodyParameter(std::string("InstanceName"), instanceName); } +std::string CreateInstanceRequest::getReplicaMode() const { + return replicaMode_; +} + +void CreateInstanceRequest::setReplicaMode(const std::string &replicaMode) { + replicaMode_ = replicaMode; + setBodyParameter(std::string("ReplicaMode"), replicaMode); +} + bool CreateInstanceRequest::getAutoRenew() const { return autoRenew_; } diff --git a/oceanbasepro/src/model/CreateInstanceResult.cc b/oceanbasepro/src/model/CreateInstanceResult.cc index 18a2a4850..534ea4365 100644 --- a/oceanbasepro/src/model/CreateInstanceResult.cc +++ b/oceanbasepro/src/model/CreateInstanceResult.cc @@ -46,6 +46,8 @@ void CreateInstanceResult::parse(const std::string &payload) data_.orderId = dataNode["OrderId"].asString(); if(!dataNode["ResourceGroupId"].isNull()) data_.resourceGroupId = dataNode["ResourceGroupId"].asString(); + if(!dataNode["DryRunResult"].isNull()) + data_.dryRunResult = dataNode["DryRunResult"].asString() == "true"; } diff --git a/oceanbasepro/src/model/CreateTenantRequest.cc b/oceanbasepro/src/model/CreateTenantRequest.cc index fd52c12c3..fcb81ea89 100644 --- a/oceanbasepro/src/model/CreateTenantRequest.cc +++ b/oceanbasepro/src/model/CreateTenantRequest.cc @@ -52,6 +52,15 @@ void CreateTenantRequest::setMemory(int memory) { setBodyParameter(std::string("Memory"), std::to_string(memory)); } +long CreateTenantRequest::getLogDisk() const { + return logDisk_; +} + +void CreateTenantRequest::setLogDisk(long logDisk) { + logDisk_ = logDisk; + setBodyParameter(std::string("LogDisk"), std::to_string(logDisk)); +} + std::string CreateTenantRequest::getTimeZone() const { return timeZone_; } @@ -133,3 +142,12 @@ void CreateTenantRequest::setTenantName(const std::string &tenantName) { setBodyParameter(std::string("TenantName"), tenantName); } +std::string CreateTenantRequest::getReadOnlyZoneList() const { + return readOnlyZoneList_; +} + +void CreateTenantRequest::setReadOnlyZoneList(const std::string &readOnlyZoneList) { + readOnlyZoneList_ = readOnlyZoneList; + setBodyParameter(std::string("ReadOnlyZoneList"), readOnlyZoneList); +} + diff --git a/oceanbasepro/src/model/DeleteInstancesRequest.cc b/oceanbasepro/src/model/DeleteInstancesRequest.cc index aa9488d59..f1ad21276 100644 --- a/oceanbasepro/src/model/DeleteInstancesRequest.cc +++ b/oceanbasepro/src/model/DeleteInstancesRequest.cc @@ -34,6 +34,15 @@ void DeleteInstancesRequest::setBackupRetainMode(const std::string &backupRetain setBodyParameter(std::string("BackupRetainMode"), backupRetainMode); } +bool DeleteInstancesRequest::getDryRun() const { + return dryRun_; +} + +void DeleteInstancesRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + std::string DeleteInstancesRequest::getInstanceIds() const { return instanceIds_; } diff --git a/oceanbasepro/src/model/DeleteInstancesResult.cc b/oceanbasepro/src/model/DeleteInstancesResult.cc index e76c9f362..1d0d1ea61 100644 --- a/oceanbasepro/src/model/DeleteInstancesResult.cc +++ b/oceanbasepro/src/model/DeleteInstancesResult.cc @@ -39,6 +39,14 @@ void DeleteInstancesResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["DryRunResult"].isNull()) + data_.dryRunResult = dataNode["DryRunResult"].asString() == "true"; } +DeleteInstancesResult::Data DeleteInstancesResult::getData()const +{ + return data_; +} + diff --git a/oceanbasepro/src/model/DescribeAvailableMemResourceResult.cc b/oceanbasepro/src/model/DescribeAvailableMemResourceResult.cc index 22d57497d..d878ca7bb 100644 --- a/oceanbasepro/src/model/DescribeAvailableMemResourceResult.cc +++ b/oceanbasepro/src/model/DescribeAvailableMemResourceResult.cc @@ -46,6 +46,8 @@ void DescribeAvailableMemResourceResult::parse(const std::string &payload) data_.maxMem = std::stol(dataNode["MaxMem"].asString()); if(!dataNode["UsedMem"].isNull()) data_.usedMem = std::stol(dataNode["UsedMem"].asString()); + if(!dataNode["SafeMem"].isNull()) + data_.safeMem = dataNode["SafeMem"].asString(); } diff --git a/oceanbasepro/src/model/DescribeAvailableSpecRequest.cc b/oceanbasepro/src/model/DescribeAvailableSpecRequest.cc new file mode 100644 index 000000000..2db9d6927 --- /dev/null +++ b/oceanbasepro/src/model/DescribeAvailableSpecRequest.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::OceanBasePro::Model::DescribeAvailableSpecRequest; + +DescribeAvailableSpecRequest::DescribeAvailableSpecRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeAvailableSpec") { + setMethod(HttpRequest::Method::Post); +} + +DescribeAvailableSpecRequest::~DescribeAvailableSpecRequest() {} + +std::string DescribeAvailableSpecRequest::getUpgradeType() const { + return upgradeType_; +} + +void DescribeAvailableSpecRequest::setUpgradeType(const std::string &upgradeType) { + upgradeType_ = upgradeType; + setBodyParameter(std::string("UpgradeType"), upgradeType); +} + +std::string DescribeAvailableSpecRequest::getSpec() const { + return spec_; +} + +void DescribeAvailableSpecRequest::setSpec(const std::string &spec) { + spec_ = spec; + setBodyParameter(std::string("Spec"), spec); +} + +std::string DescribeAvailableSpecRequest::getInstanceId() const { + return instanceId_; +} + +void DescribeAvailableSpecRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + diff --git a/oceanbasepro/src/model/DescribeAvailableSpecResult.cc b/oceanbasepro/src/model/DescribeAvailableSpecResult.cc new file mode 100644 index 000000000..23da554f7 --- /dev/null +++ b/oceanbasepro/src/model/DescribeAvailableSpecResult.cc @@ -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 +#include + +using namespace AlibabaCloud::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +DescribeAvailableSpecResult::DescribeAvailableSpecResult() : + ServiceResult() +{} + +DescribeAvailableSpecResult::DescribeAvailableSpecResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeAvailableSpecResult::~DescribeAvailableSpecResult() +{} + +void DescribeAvailableSpecResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allAvailableSpecificationsNode = dataNode["AvailableSpecifications"]["AvailableSpecificationsItem"]; + for (auto dataNodeAvailableSpecificationsAvailableSpecificationsItem : allAvailableSpecificationsNode) + { + Data::AvailableSpecificationsItem availableSpecificationsItemObject; + if(!dataNodeAvailableSpecificationsAvailableSpecificationsItem["Spec"].isNull()) + availableSpecificationsItemObject.spec = dataNodeAvailableSpecificationsAvailableSpecificationsItem["Spec"].asString(); + if(!dataNodeAvailableSpecificationsAvailableSpecificationsItem["InstanceClass"].isNull()) + availableSpecificationsItemObject.instanceClass = dataNodeAvailableSpecificationsAvailableSpecificationsItem["InstanceClass"].asString(); + auto diskSizeRangeNode = value["DiskSizeRange"]; + if(!diskSizeRangeNode["Step"].isNull()) + availableSpecificationsItemObject.diskSizeRange.step = std::stol(diskSizeRangeNode["Step"].asString()); + if(!diskSizeRangeNode["Max"].isNull()) + availableSpecificationsItemObject.diskSizeRange.max = std::stol(diskSizeRangeNode["Max"].asString()); + if(!diskSizeRangeNode["Min"].isNull()) + availableSpecificationsItemObject.diskSizeRange.min = std::stol(diskSizeRangeNode["Min"].asString()); + auto logDiskSizeRangeNode = value["LogDiskSizeRange"]; + if(!logDiskSizeRangeNode["Step"].isNull()) + availableSpecificationsItemObject.logDiskSizeRange.step = std::stol(logDiskSizeRangeNode["Step"].asString()); + if(!logDiskSizeRangeNode["Max"].isNull()) + availableSpecificationsItemObject.logDiskSizeRange.max = std::stol(logDiskSizeRangeNode["Max"].asString()); + if(!logDiskSizeRangeNode["Min"].isNull()) + availableSpecificationsItemObject.logDiskSizeRange.min = std::stol(logDiskSizeRangeNode["Min"].asString()); + auto allNodeNum = value["NodeNum"]["NodeNum"]; + for (auto value : allNodeNum) + availableSpecificationsItemObject.nodeNum.push_back(value.asString()); + data_.availableSpecifications.push_back(availableSpecificationsItemObject); + } + +} + +DescribeAvailableSpecResult::Data DescribeAvailableSpecResult::getData()const +{ + return data_; +} + diff --git a/oceanbasepro/src/model/DescribeAvailableZoneRequest.cc b/oceanbasepro/src/model/DescribeAvailableZoneRequest.cc new file mode 100644 index 000000000..73c80f784 --- /dev/null +++ b/oceanbasepro/src/model/DescribeAvailableZoneRequest.cc @@ -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 + +using AlibabaCloud::OceanBasePro::Model::DescribeAvailableZoneRequest; + +DescribeAvailableZoneRequest::DescribeAvailableZoneRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeAvailableZone") { + setMethod(HttpRequest::Method::Post); +} + +DescribeAvailableZoneRequest::~DescribeAvailableZoneRequest() {} + +std::string DescribeAvailableZoneRequest::getSpec() const { + return spec_; +} + +void DescribeAvailableZoneRequest::setSpec(const std::string &spec) { + spec_ = spec; + setBodyParameter(std::string("Spec"), spec); +} + +std::string DescribeAvailableZoneRequest::getObVersion() const { + return obVersion_; +} + +void DescribeAvailableZoneRequest::setObVersion(const std::string &obVersion) { + obVersion_ = obVersion; + setBodyParameter(std::string("ObVersion"), obVersion); +} + +std::string DescribeAvailableZoneRequest::getSeries() const { + return series_; +} + +void DescribeAvailableZoneRequest::setSeries(const std::string &series) { + series_ = series; + setBodyParameter(std::string("Series"), series); +} + +std::string DescribeAvailableZoneRequest::getInstanceType() const { + return instanceType_; +} + +void DescribeAvailableZoneRequest::setInstanceType(const std::string &instanceType) { + instanceType_ = instanceType; + setBodyParameter(std::string("InstanceType"), instanceType); +} + +std::string DescribeAvailableZoneRequest::getDeployType() const { + return deployType_; +} + +void DescribeAvailableZoneRequest::setDeployType(const std::string &deployType) { + deployType_ = deployType; + setBodyParameter(std::string("DeployType"), deployType); +} + diff --git a/oceanbasepro/src/model/DescribeAvailableZoneResult.cc b/oceanbasepro/src/model/DescribeAvailableZoneResult.cc new file mode 100644 index 000000000..8ece9a694 --- /dev/null +++ b/oceanbasepro/src/model/DescribeAvailableZoneResult.cc @@ -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 +#include + +using namespace AlibabaCloud::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +DescribeAvailableZoneResult::DescribeAvailableZoneResult() : + ServiceResult() +{} + +DescribeAvailableZoneResult::DescribeAvailableZoneResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeAvailableZoneResult::~DescribeAvailableZoneResult() +{} + +void DescribeAvailableZoneResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allAvailableZonesNode = dataNode["AvailableZones"]["AvailableZonesItem"]; + for (auto dataNodeAvailableZonesAvailableZonesItem : allAvailableZonesNode) + { + Data::AvailableZonesItem availableZonesItemObject; + if(!dataNodeAvailableZonesAvailableZonesItem["Region"].isNull()) + availableZonesItemObject.region = dataNodeAvailableZonesAvailableZonesItem["Region"].asString(); + if(!dataNodeAvailableZonesAvailableZonesItem["Zones"].isNull()) + availableZonesItemObject.zones = dataNodeAvailableZonesAvailableZonesItem["Zones"].asString(); + if(!dataNodeAvailableZonesAvailableZonesItem["Channel"].isNull()) + availableZonesItemObject.channel = dataNodeAvailableZonesAvailableZonesItem["Channel"].asString(); + if(!dataNodeAvailableZonesAvailableZonesItem["DeployType"].isNull()) + availableZonesItemObject.deployType = dataNodeAvailableZonesAvailableZonesItem["DeployType"].asString(); + if(!dataNodeAvailableZonesAvailableZonesItem["InstanceType"].isNull()) + availableZonesItemObject.instanceType = dataNodeAvailableZonesAvailableZonesItem["InstanceType"].asString(); + if(!dataNodeAvailableZonesAvailableZonesItem["Series"].isNull()) + availableZonesItemObject.series = dataNodeAvailableZonesAvailableZonesItem["Series"].asString(); + auto allSupportSpecificationsNode = dataNodeAvailableZonesAvailableZonesItem["SupportSpecifications"]["SupportSpecificationsItem"]; + for (auto dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem : allSupportSpecificationsNode) + { + Data::AvailableZonesItem::SupportSpecificationsItem supportSpecificationsObject; + if(!dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["Spec"].isNull()) + supportSpecificationsObject.spec = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["Spec"].asString(); + if(!dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["InstanceClass"].isNull()) + supportSpecificationsObject.instanceClass = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["InstanceClass"].asString(); + auto allSupportEngineVersionsNode = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["SupportEngineVersions"]["SupportEngineVersionsItem"]; + for (auto dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem : allSupportEngineVersionsNode) + { + Data::AvailableZonesItem::SupportSpecificationsItem::SupportEngineVersionsItem supportEngineVersionsObject; + if(!dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem["ObVersion"].isNull()) + supportEngineVersionsObject.obVersion = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem["ObVersion"].asString(); + if(!dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem["SupportIsolationOptimization"].isNull()) + supportEngineVersionsObject.supportIsolationOptimization = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem["SupportIsolationOptimization"].asString() == "true"; + auto allSupportReplicaModes = value["SupportReplicaModes"]["SupportReplicaModes"]; + for (auto value : allSupportReplicaModes) + supportEngineVersionsObject.supportReplicaModes.push_back(value.asString()); + supportSpecificationsObject.supportEngineVersions.push_back(supportEngineVersionsObject); + } + auto diskSizeRangeNode = value["DiskSizeRange"]; + if(!diskSizeRangeNode["Step"].isNull()) + supportSpecificationsObject.diskSizeRange.step = std::stol(diskSizeRangeNode["Step"].asString()); + if(!diskSizeRangeNode["Max"].isNull()) + supportSpecificationsObject.diskSizeRange.max = std::stol(diskSizeRangeNode["Max"].asString()); + if(!diskSizeRangeNode["Min"].isNull()) + supportSpecificationsObject.diskSizeRange.min = std::stol(diskSizeRangeNode["Min"].asString()); + auto allDiskTypes = value["DiskTypes"]["DiskTypes"]; + for (auto value : allDiskTypes) + supportSpecificationsObject.diskTypes.push_back(value.asString()); + availableZonesItemObject.supportSpecifications.push_back(supportSpecificationsObject); + } + data_.availableZones.push_back(availableZonesItemObject); + } + +} + +DescribeAvailableZoneResult::Data DescribeAvailableZoneResult::getData()const +{ + return data_; +} + diff --git a/oceanbasepro/src/model/DescribeDatabasesRequest.cc b/oceanbasepro/src/model/DescribeDatabasesRequest.cc index 2d8aafce2..1e99601d6 100644 --- a/oceanbasepro/src/model/DescribeDatabasesRequest.cc +++ b/oceanbasepro/src/model/DescribeDatabasesRequest.cc @@ -43,6 +43,15 @@ void DescribeDatabasesRequest::setPageNumber(int pageNumber) { setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber)); } +std::string DescribeDatabasesRequest::getInstanceId() const { + return instanceId_; +} + +void DescribeDatabasesRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + std::string DescribeDatabasesRequest::getDatabaseName() const { return databaseName_; } diff --git a/oceanbasepro/src/model/DescribeDatabasesResult.cc b/oceanbasepro/src/model/DescribeDatabasesResult.cc index 3ea2aa098..bc1ad4549 100644 --- a/oceanbasepro/src/model/DescribeDatabasesResult.cc +++ b/oceanbasepro/src/model/DescribeDatabasesResult.cc @@ -65,6 +65,8 @@ void DescribeDatabasesResult::parse(const std::string &payload) databasesObject.collation = valueDatabasesData["Collation"].asString(); if(!valueDatabasesData["InstanceId"].isNull()) databasesObject.instanceId = valueDatabasesData["InstanceId"].asString(); + if(!valueDatabasesData["TenantName"].isNull()) + databasesObject.tenantName = valueDatabasesData["TenantName"].asString(); auto allUsersNode = valueDatabasesData["Users"]["UsersItem"]; for (auto valueDatabasesDataUsersUsersItem : allUsersNode) { diff --git a/oceanbasepro/src/model/DescribeInstanceResult.cc b/oceanbasepro/src/model/DescribeInstanceResult.cc index d60c60701..0f38e3353 100644 --- a/oceanbasepro/src/model/DescribeInstanceResult.cc +++ b/oceanbasepro/src/model/DescribeInstanceResult.cc @@ -94,6 +94,14 @@ void DescribeInstanceResult::parse(const std::string &payload) instance_.inTempCapacityStatus = instanceNode["InTempCapacityStatus"].asString() == "true"; if(!instanceNode["DataDiskAutoScale"].isNull()) instance_.dataDiskAutoScale = instanceNode["DataDiskAutoScale"].asString() == "true"; + if(!instanceNode["EnableProxyService"].isNull()) + instance_.enableProxyService = instanceNode["EnableProxyService"].asString() == "true"; + if(!instanceNode["ProxyServiceStatus"].isNull()) + instance_.proxyServiceStatus = instanceNode["ProxyServiceStatus"].asString(); + if(!instanceNode["ProxyClusterId"].isNull()) + instance_.proxyClusterId = instanceNode["ProxyClusterId"].asString(); + if(!instanceNode["CpuArchitecture"].isNull()) + instance_.cpuArchitecture = instanceNode["CpuArchitecture"].asString(); auto resourceNode = instanceNode["Resource"]; if(!resourceNode["UnitCount"].isNull()) instance_.resource.unitCount = std::stol(resourceNode["UnitCount"].asString()); @@ -138,6 +146,13 @@ void DescribeInstanceResult::parse(const std::string &payload) instance_.resource.logDiskSize.totalDiskSize = std::stol(logDiskSizeNode["TotalDiskSize"].asString()); if(!logDiskSizeNode["UnitDiskSize"].isNull()) instance_.resource.logDiskSize.unitDiskSize = std::stol(logDiskSizeNode["UnitDiskSize"].asString()); + if(!logDiskSizeNode["LogAssignedSize"].isNull()) + instance_.resource.logDiskSize.logAssignedSize = logDiskSizeNode["LogAssignedSize"].asString(); + if(!logDiskSizeNode["MaxLogAssignedPercent"].isNull()) + instance_.resource.logDiskSize.maxLogAssignedPercent = logDiskSizeNode["MaxLogAssignedPercent"].asString(); + auto allMaxLogAssignedObServer = logDiskSizeNode["MaxLogAssignedObServer"]["MaxLogAssignedObServer"]; + for (auto value : allMaxLogAssignedObServer) + instance_.resource.logDiskSize.maxLogAssignedObServer.push_back(value.asString()); auto capacityUnitNode = resourceNode["CapacityUnit"]; if(!capacityUnitNode["MaxCapacityUnit"].isNull()) instance_.resource.capacityUnit.maxCapacityUnit = std::stoi(capacityUnitNode["MaxCapacityUnit"].asString()); diff --git a/oceanbasepro/src/model/DescribeInstanceSecurityConfigsRequest.cc b/oceanbasepro/src/model/DescribeInstanceSecurityConfigsRequest.cc index e17bb78ad..77363c7d0 100644 --- a/oceanbasepro/src/model/DescribeInstanceSecurityConfigsRequest.cc +++ b/oceanbasepro/src/model/DescribeInstanceSecurityConfigsRequest.cc @@ -34,3 +34,12 @@ void DescribeInstanceSecurityConfigsRequest::setInstanceId(const std::string &in setBodyParameter(std::string("InstanceId"), instanceId); } +std::string DescribeInstanceSecurityConfigsRequest::getCheckId() const { + return checkId_; +} + +void DescribeInstanceSecurityConfigsRequest::setCheckId(const std::string &checkId) { + checkId_ = checkId; + setBodyParameter(std::string("CheckId"), checkId); +} + diff --git a/oceanbasepro/src/model/DescribeInstanceSecurityConfigsResult.cc b/oceanbasepro/src/model/DescribeInstanceSecurityConfigsResult.cc index 3179f0840..bf74fb63a 100644 --- a/oceanbasepro/src/model/DescribeInstanceSecurityConfigsResult.cc +++ b/oceanbasepro/src/model/DescribeInstanceSecurityConfigsResult.cc @@ -44,6 +44,12 @@ void DescribeInstanceSecurityConfigsResult::parse(const std::string &payload) instanceSecurityConfigs_.totalCheckCount = std::stoi(instanceSecurityConfigsNode["TotalCheckCount"].asString()); if(!instanceSecurityConfigsNode["TotalRiskCount"].isNull()) instanceSecurityConfigs_.totalRiskCount = std::stoi(instanceSecurityConfigsNode["TotalRiskCount"].asString()); + if(!instanceSecurityConfigsNode["CheckTime"].isNull()) + instanceSecurityConfigs_.checkTime = instanceSecurityConfigsNode["CheckTime"].asString(); + if(!instanceSecurityConfigsNode["InstanceId"].isNull()) + instanceSecurityConfigs_.instanceId = instanceSecurityConfigsNode["InstanceId"].asString(); + if(!instanceSecurityConfigsNode["CheckId"].isNull()) + instanceSecurityConfigs_.checkId = instanceSecurityConfigsNode["CheckId"].asString(); auto allSecurityConfigsNode = instanceSecurityConfigsNode["SecurityConfigs"]["SecurityConfigsItem"]; for (auto instanceSecurityConfigsNodeSecurityConfigsSecurityConfigsItem : allSecurityConfigsNode) { diff --git a/oceanbasepro/src/model/DescribeInstancesResult.cc b/oceanbasepro/src/model/DescribeInstancesResult.cc index 73d55051e..947c9ebc6 100644 --- a/oceanbasepro/src/model/DescribeInstancesResult.cc +++ b/oceanbasepro/src/model/DescribeInstancesResult.cc @@ -57,6 +57,8 @@ void DescribeInstancesResult::parse(const std::string &payload) instancesObject.createTime = valueInstancesData["CreateTime"].asString(); if(!valueInstancesData["DeployMode"].isNull()) instancesObject.deployMode = valueInstancesData["DeployMode"].asString(); + if(!valueInstancesData["CpuArchitecture"].isNull()) + instancesObject.cpuArchitecture = valueInstancesData["CpuArchitecture"].asString(); if(!valueInstancesData["MaintainTime"].isNull()) instancesObject.maintainTime = valueInstancesData["MaintainTime"].asString(); if(!valueInstancesData["DeployType"].isNull()) diff --git a/oceanbasepro/src/model/DescribeSQLSamplesResult.cc b/oceanbasepro/src/model/DescribeSQLSamplesResult.cc index 0efd1bac6..e9e61b6da 100644 --- a/oceanbasepro/src/model/DescribeSQLSamplesResult.cc +++ b/oceanbasepro/src/model/DescribeSQLSamplesResult.cc @@ -84,9 +84,9 @@ void DescribeSQLSamplesResult::parse(const std::string &payload) if(!valueDataDataItem["Inner"].isNull()) dataObject.inner = valueDataDataItem["Inner"].asString() == "true"; if(!valueDataDataItem["ExecutorRpc"].isNull()) - dataObject.executorRpc = valueDataDataItem["ExecutorRpc"].asString(); + dataObject.executorRpc = valueDataDataItem["ExecutorRpc"].asString() == "true"; if(!valueDataDataItem["HitPlan"].isNull()) - dataObject.hitPlan = valueDataDataItem["HitPlan"].asString(); + dataObject.hitPlan = valueDataDataItem["HitPlan"].asString() == "true"; if(!valueDataDataItem["ElapsedTime"].isNull()) dataObject.elapsedTime = valueDataDataItem["ElapsedTime"].asString(); if(!valueDataDataItem["CpuTime"].isNull()) @@ -124,7 +124,7 @@ void DescribeSQLSamplesResult::parse(const std::string &payload) if(!valueDataDataItem["RetryCount"].isNull()) dataObject.retryCount = valueDataDataItem["RetryCount"].asString(); if(!valueDataDataItem["TableScan"].isNull()) - dataObject.tableScan = valueDataDataItem["TableScan"].asString(); + dataObject.tableScan = valueDataDataItem["TableScan"].asString() == "true"; if(!valueDataDataItem["ConsistencyLevel"].isNull()) dataObject.consistencyLevel = valueDataDataItem["ConsistencyLevel"].asString(); if(!valueDataDataItem["MemstoreReadRows"].isNull()) @@ -145,6 +145,8 @@ void DescribeSQLSamplesResult::parse(const std::string &payload) dataObject.statement = valueDataDataItem["Statement"].asString(); if(!valueDataDataItem["TransHash"].isNull()) dataObject.transHash = valueDataDataItem["TransHash"].asString(); + if(!valueDataDataItem["FullSqlText"].isNull()) + dataObject.fullSqlText = valueDataDataItem["FullSqlText"].asString(); data_.push_back(dataObject); } diff --git a/oceanbasepro/src/model/DescribeTenantEncryptionRequest.cc b/oceanbasepro/src/model/DescribeTenantEncryptionRequest.cc new file mode 100644 index 000000000..b429323a5 --- /dev/null +++ b/oceanbasepro/src/model/DescribeTenantEncryptionRequest.cc @@ -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 + +using AlibabaCloud::OceanBasePro::Model::DescribeTenantEncryptionRequest; + +DescribeTenantEncryptionRequest::DescribeTenantEncryptionRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeTenantEncryption") { + setMethod(HttpRequest::Method::Post); +} + +DescribeTenantEncryptionRequest::~DescribeTenantEncryptionRequest() {} + +long DescribeTenantEncryptionRequest::getPageNumber() const { + return pageNumber_; +} + +void DescribeTenantEncryptionRequest::setPageNumber(long pageNumber) { + pageNumber_ = pageNumber; + setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +std::string DescribeTenantEncryptionRequest::getInstanceId() const { + return instanceId_; +} + +void DescribeTenantEncryptionRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + +std::string DescribeTenantEncryptionRequest::getTenantId() const { + return tenantId_; +} + +void DescribeTenantEncryptionRequest::setTenantId(const std::string &tenantId) { + tenantId_ = tenantId; + setBodyParameter(std::string("TenantId"), tenantId); +} + +long DescribeTenantEncryptionRequest::getPageSize() const { + return pageSize_; +} + +void DescribeTenantEncryptionRequest::setPageSize(long pageSize) { + pageSize_ = pageSize; + setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string DescribeTenantEncryptionRequest::getTenantName() const { + return tenantName_; +} + +void DescribeTenantEncryptionRequest::setTenantName(const std::string &tenantName) { + tenantName_ = tenantName; + setBodyParameter(std::string("TenantName"), tenantName); +} + diff --git a/oceanbasepro/src/model/DescribeTenantEncryptionResult.cc b/oceanbasepro/src/model/DescribeTenantEncryptionResult.cc new file mode 100644 index 000000000..9dbd97d5a --- /dev/null +++ b/oceanbasepro/src/model/DescribeTenantEncryptionResult.cc @@ -0,0 +1,78 @@ +/* + * 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::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +DescribeTenantEncryptionResult::DescribeTenantEncryptionResult() : + ServiceResult() +{} + +DescribeTenantEncryptionResult::DescribeTenantEncryptionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeTenantEncryptionResult::~DescribeTenantEncryptionResult() +{} + +void DescribeTenantEncryptionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allTenantEncryptionsNode = value["TenantEncryptions"]["TenantEncryptionsItem"]; + for (auto valueTenantEncryptionsTenantEncryptionsItem : allTenantEncryptionsNode) + { + TenantEncryptionsItem tenantEncryptionsObject; + if(!valueTenantEncryptionsTenantEncryptionsItem["TenantId"].isNull()) + tenantEncryptionsObject.tenantId = valueTenantEncryptionsTenantEncryptionsItem["TenantId"].asString(); + if(!valueTenantEncryptionsTenantEncryptionsItem["TenantMode"].isNull()) + tenantEncryptionsObject.tenantMode = valueTenantEncryptionsTenantEncryptionsItem["TenantMode"].asString(); + if(!valueTenantEncryptionsTenantEncryptionsItem["TenantName"].isNull()) + tenantEncryptionsObject.tenantName = valueTenantEncryptionsTenantEncryptionsItem["TenantName"].asString(); + if(!valueTenantEncryptionsTenantEncryptionsItem["EnableEncryption"].isNull()) + tenantEncryptionsObject.enableEncryption = valueTenantEncryptionsTenantEncryptionsItem["EnableEncryption"].asString() == "true"; + if(!valueTenantEncryptionsTenantEncryptionsItem["TenantStatus"].isNull()) + tenantEncryptionsObject.tenantStatus = valueTenantEncryptionsTenantEncryptionsItem["TenantStatus"].asString(); + if(!valueTenantEncryptionsTenantEncryptionsItem["Status"].isNull()) + tenantEncryptionsObject.status = valueTenantEncryptionsTenantEncryptionsItem["Status"].asString(); + if(!valueTenantEncryptionsTenantEncryptionsItem["EncryptionType"].isNull()) + tenantEncryptionsObject.encryptionType = valueTenantEncryptionsTenantEncryptionsItem["EncryptionType"].asString(); + if(!valueTenantEncryptionsTenantEncryptionsItem["EncryptionKeyId"].isNull()) + tenantEncryptionsObject.encryptionKeyId = valueTenantEncryptionsTenantEncryptionsItem["EncryptionKeyId"].asString(); + tenantEncryptions_.push_back(tenantEncryptionsObject); + } + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); + +} + +int DescribeTenantEncryptionResult::getTotalCount()const +{ + return totalCount_; +} + +std::vector DescribeTenantEncryptionResult::getTenantEncryptions()const +{ + return tenantEncryptions_; +} + diff --git a/oceanbasepro/src/model/DescribeTenantResult.cc b/oceanbasepro/src/model/DescribeTenantResult.cc index caff9ddd6..03717bdf1 100644 --- a/oceanbasepro/src/model/DescribeTenantResult.cc +++ b/oceanbasepro/src/model/DescribeTenantResult.cc @@ -126,6 +126,8 @@ void DescribeTenantResult::parse(const std::string &payload) tenantConnectionsItemObject.parallelQueryDegree = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["ParallelQueryDegree"].asString()); if(!tenantNodeTenantConnectionsTenantConnectionsItem["TenantEndpointId"].isNull()) tenantConnectionsItemObject.tenantEndpointId = tenantNodeTenantConnectionsTenantConnectionsItem["TenantEndpointId"].asString(); + if(!tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].isNull()) + tenantConnectionsItemObject.maxConnectionNum = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].asString()); auto allConnectionZones = value["ConnectionZones"]["ConnectionZones"]; for (auto value : allConnectionZones) tenantConnectionsItemObject.connectionZones.push_back(value.asString()); @@ -170,6 +172,11 @@ void DescribeTenantResult::parse(const std::string &payload) tenant_.tenantResource.capacityUnit.minCapacityUnit = std::stoi(capacityUnitNode["MinCapacityUnit"].asString()); if(!capacityUnitNode["UsedCapacit"].isNull()) tenant_.tenantResource.capacityUnit.usedCapacit = std::stoi(capacityUnitNode["UsedCapacit"].asString()); + auto logDiskSizeNode = tenantResourceNode["LogDiskSize"]; + if(!logDiskSizeNode["TotalLogDisk"].isNull()) + tenant_.tenantResource.logDiskSize.totalLogDisk = std::stoi(logDiskSizeNode["TotalLogDisk"].asString()); + if(!logDiskSizeNode["UnitLogDisk"].isNull()) + tenant_.tenantResource.logDiskSize.unitLogDisk = std::stoi(logDiskSizeNode["UnitLogDisk"].asString()); auto allAvailableZones = tenantNode["AvailableZones"]["AvailableZones"]; for (auto value : allAvailableZones) tenant_.availableZones.push_back(value.asString()); diff --git a/oceanbasepro/src/model/DescribeTenantSecurityConfigsRequest.cc b/oceanbasepro/src/model/DescribeTenantSecurityConfigsRequest.cc index 23dbda44b..b5a1a4207 100644 --- a/oceanbasepro/src/model/DescribeTenantSecurityConfigsRequest.cc +++ b/oceanbasepro/src/model/DescribeTenantSecurityConfigsRequest.cc @@ -43,3 +43,12 @@ void DescribeTenantSecurityConfigsRequest::setTenantId(const std::string &tenant setBodyParameter(std::string("TenantId"), tenantId); } +std::string DescribeTenantSecurityConfigsRequest::getCheckId() const { + return checkId_; +} + +void DescribeTenantSecurityConfigsRequest::setCheckId(const std::string &checkId) { + checkId_ = checkId; + setBodyParameter(std::string("CheckId"), checkId); +} + diff --git a/oceanbasepro/src/model/DescribeTenantSecurityConfigsResult.cc b/oceanbasepro/src/model/DescribeTenantSecurityConfigsResult.cc index 9b2f71802..31b02935d 100644 --- a/oceanbasepro/src/model/DescribeTenantSecurityConfigsResult.cc +++ b/oceanbasepro/src/model/DescribeTenantSecurityConfigsResult.cc @@ -44,6 +44,12 @@ void DescribeTenantSecurityConfigsResult::parse(const std::string &payload) configs_.totalCheckCount = std::stoi(configsNode["TotalCheckCount"].asString()); if(!configsNode["TotalRiskCount"].isNull()) configs_.totalRiskCount = std::stoi(configsNode["TotalRiskCount"].asString()); + if(!configsNode["CheckId"].isNull()) + configs_.checkId = configsNode["CheckId"].asString(); + if(!configsNode["InstanceId"].isNull()) + configs_.instanceId = configsNode["InstanceId"].asString(); + if(!configsNode["CheckTime"].isNull()) + configs_.checkTime = configsNode["CheckTime"].asString(); auto allTenantSecurityConfigsNode = configsNode["TenantSecurityConfigs"]["TenantSecurityConfigsItem"]; for (auto configsNodeTenantSecurityConfigsTenantSecurityConfigsItem : allTenantSecurityConfigsNode) { diff --git a/oceanbasepro/src/model/ModifyInstanceNodeNumRequest.cc b/oceanbasepro/src/model/ModifyInstanceNodeNumRequest.cc index 5bf8ccfc4..dca31b29f 100644 --- a/oceanbasepro/src/model/ModifyInstanceNodeNumRequest.cc +++ b/oceanbasepro/src/model/ModifyInstanceNodeNumRequest.cc @@ -25,6 +25,15 @@ ModifyInstanceNodeNumRequest::ModifyInstanceNodeNumRequest() ModifyInstanceNodeNumRequest::~ModifyInstanceNodeNumRequest() {} +bool ModifyInstanceNodeNumRequest::getDryRun() const { + return dryRun_; +} + +void ModifyInstanceNodeNumRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + std::string ModifyInstanceNodeNumRequest::getNodeNum() const { return nodeNum_; } diff --git a/oceanbasepro/src/model/ModifyInstanceNodeNumResult.cc b/oceanbasepro/src/model/ModifyInstanceNodeNumResult.cc index 1fa34cfe9..fc79fc201 100644 --- a/oceanbasepro/src/model/ModifyInstanceNodeNumResult.cc +++ b/oceanbasepro/src/model/ModifyInstanceNodeNumResult.cc @@ -42,6 +42,8 @@ void ModifyInstanceNodeNumResult::parse(const std::string &payload) auto dataNode = value["Data"]; if(!dataNode["OrderId"].isNull()) data_.orderId = dataNode["OrderId"].asString(); + if(!dataNode["DryRunResult"].isNull()) + data_.dryRunResult = dataNode["DryRunResult"].asString() == "true"; } diff --git a/oceanbasepro/src/model/ModifyInstanceSpecRequest.cc b/oceanbasepro/src/model/ModifyInstanceSpecRequest.cc index 54148730c..aa1d72e35 100644 --- a/oceanbasepro/src/model/ModifyInstanceSpecRequest.cc +++ b/oceanbasepro/src/model/ModifyInstanceSpecRequest.cc @@ -43,6 +43,15 @@ void ModifyInstanceSpecRequest::setInstanceClass(const std::string &instanceClas setBodyParameter(std::string("InstanceClass"), instanceClass); } +bool ModifyInstanceSpecRequest::getDryRun() const { + return dryRun_; +} + +void ModifyInstanceSpecRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + long ModifyInstanceSpecRequest::getDiskSize() const { return diskSize_; } diff --git a/oceanbasepro/src/model/ModifyInstanceSpecResult.cc b/oceanbasepro/src/model/ModifyInstanceSpecResult.cc index caaff3202..aee33d61f 100644 --- a/oceanbasepro/src/model/ModifyInstanceSpecResult.cc +++ b/oceanbasepro/src/model/ModifyInstanceSpecResult.cc @@ -42,6 +42,8 @@ void ModifyInstanceSpecResult::parse(const std::string &payload) auto dataNode = value["Data"]; if(!dataNode["OrderId"].isNull()) data_.orderId = dataNode["OrderId"].asString(); + if(!dataNode["DryRunResult"].isNull()) + data_.dryRunResult = dataNode["DryRunResult"].asString() == "true"; } diff --git a/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc b/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc new file mode 100644 index 000000000..6df879371 --- /dev/null +++ b/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::OceanBasePro::Model::ModifyInstanceTemporaryCapacityRequest; + +ModifyInstanceTemporaryCapacityRequest::ModifyInstanceTemporaryCapacityRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "ModifyInstanceTemporaryCapacity") { + setMethod(HttpRequest::Method::Post); +} + +ModifyInstanceTemporaryCapacityRequest::~ModifyInstanceTemporaryCapacityRequest() {} + +std::string ModifyInstanceTemporaryCapacityRequest::getDiskSize() const { + return diskSize_; +} + +void ModifyInstanceTemporaryCapacityRequest::setDiskSize(const std::string &diskSize) { + diskSize_ = diskSize; + setBodyParameter(std::string("DiskSize"), diskSize); +} + +std::string ModifyInstanceTemporaryCapacityRequest::getSpec() const { + return spec_; +} + +void ModifyInstanceTemporaryCapacityRequest::setSpec(const std::string &spec) { + spec_ = spec; + setBodyParameter(std::string("Spec"), spec); +} + +std::string ModifyInstanceTemporaryCapacityRequest::getInstanceId() const { + return instanceId_; +} + +void ModifyInstanceTemporaryCapacityRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + diff --git a/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityResult.cc b/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityResult.cc new file mode 100644 index 000000000..c817ef890 --- /dev/null +++ b/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityResult.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::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +ModifyInstanceTemporaryCapacityResult::ModifyInstanceTemporaryCapacityResult() : + ServiceResult() +{} + +ModifyInstanceTemporaryCapacityResult::ModifyInstanceTemporaryCapacityResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyInstanceTemporaryCapacityResult::~ModifyInstanceTemporaryCapacityResult() +{} + +void ModifyInstanceTemporaryCapacityResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/oceanbasepro/src/model/ModifyTenantResourceRequest.cc b/oceanbasepro/src/model/ModifyTenantResourceRequest.cc index 034a557ef..f9299f594 100644 --- a/oceanbasepro/src/model/ModifyTenantResourceRequest.cc +++ b/oceanbasepro/src/model/ModifyTenantResourceRequest.cc @@ -34,6 +34,15 @@ void ModifyTenantResourceRequest::setMemory(int memory) { setBodyParameter(std::string("Memory"), std::to_string(memory)); } +long ModifyTenantResourceRequest::getLogDisk() const { + return logDisk_; +} + +void ModifyTenantResourceRequest::setLogDisk(long logDisk) { + logDisk_ = logDisk; + setBodyParameter(std::string("LogDisk"), std::to_string(logDisk)); +} + int ModifyTenantResourceRequest::getCpu() const { return cpu_; } @@ -61,3 +70,12 @@ void ModifyTenantResourceRequest::setTenantId(const std::string &tenantId) { setBodyParameter(std::string("TenantId"), tenantId); } +std::string ModifyTenantResourceRequest::getReadOnlyZoneList() const { + return readOnlyZoneList_; +} + +void ModifyTenantResourceRequest::setReadOnlyZoneList(const std::string &readOnlyZoneList) { + readOnlyZoneList_ = readOnlyZoneList; + setBodyParameter(std::string("ReadOnlyZoneList"), readOnlyZoneList); +} +