Generated 2019-09-01 for OceanBasePro.

VERSION

@@ -1 +1 @@
-1.36.1929
+1.36.1930

oceanbasepro/CMakeLists.txt

@@ -173,6 +173,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantMetricsRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantMetricsResult.h
+	include/alibabacloud/oceanbasepro/model/DescribeTenantReadableScnRequest.h
+	include/alibabacloud/oceanbasepro/model/DescribeTenantReadableScnResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityIpGroupsRequest.h
@@ -217,6 +219,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceNameResult.h
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumRequest.h
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumResult.h
+	include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h
+	include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecResult.h
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceTagsRequest.h
@@ -426,6 +430,8 @@ set(oceanbasepro_src
 	src/model/DescribeTenantEncryptionResult.cc
 	src/model/DescribeTenantMetricsRequest.cc
 	src/model/DescribeTenantMetricsResult.cc
+	src/model/DescribeTenantReadableScnRequest.cc
+	src/model/DescribeTenantReadableScnResult.cc
 	src/model/DescribeTenantSecurityConfigsRequest.cc
 	src/model/DescribeTenantSecurityConfigsResult.cc
 	src/model/DescribeTenantSecurityIpGroupsRequest.cc
@@ -470,6 +476,8 @@ set(oceanbasepro_src
 	src/model/ModifyInstanceNameResult.cc
 	src/model/ModifyInstanceNodeNumRequest.cc
 	src/model/ModifyInstanceNodeNumResult.cc
+	src/model/ModifyInstanceSSLRequest.cc
+	src/model/ModifyInstanceSSLResult.cc
 	src/model/ModifyInstanceSpecRequest.cc
 	src/model/ModifyInstanceSpecResult.cc
 	src/model/ModifyInstanceTagsRequest.cc

oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h

@@ -174,6 +174,8 @@
 #include "model/DescribeTenantEncryptionResult.h"
 #include "model/DescribeTenantMetricsRequest.h"
 #include "model/DescribeTenantMetricsResult.h"
+#include "model/DescribeTenantReadableScnRequest.h"
+#include "model/DescribeTenantReadableScnResult.h"
 #include "model/DescribeTenantSecurityConfigsRequest.h"
 #include "model/DescribeTenantSecurityConfigsResult.h"
 #include "model/DescribeTenantSecurityIpGroupsRequest.h"
@@ -218,6 +220,8 @@
 #include "model/ModifyInstanceNameResult.h"
 #include "model/ModifyInstanceNodeNumRequest.h"
 #include "model/ModifyInstanceNodeNumResult.h"
+#include "model/ModifyInstanceSSLRequest.h"
+#include "model/ModifyInstanceSSLResult.h"
 #include "model/ModifyInstanceSpecRequest.h"
 #include "model/ModifyInstanceSpecResult.h"
 #include "model/ModifyInstanceTagsRequest.h"
@@ -509,6 +513,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeTenantMetricsResult> DescribeTenantMetricsOutcome;
 			typedef std::future<DescribeTenantMetricsOutcome> DescribeTenantMetricsOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeTenantMetricsRequest&, const DescribeTenantMetricsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTenantMetricsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeTenantReadableScnResult> DescribeTenantReadableScnOutcome;
+			typedef std::future<DescribeTenantReadableScnOutcome> DescribeTenantReadableScnOutcomeCallable;
+			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeTenantReadableScnRequest&, const DescribeTenantReadableScnOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTenantReadableScnAsyncHandler;
 			typedef Outcome<Error, Model::DescribeTenantSecurityConfigsResult> DescribeTenantSecurityConfigsOutcome;
 			typedef std::future<DescribeTenantSecurityConfigsOutcome> DescribeTenantSecurityConfigsOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeTenantSecurityConfigsRequest&, const DescribeTenantSecurityConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTenantSecurityConfigsAsyncHandler;
@@ -575,6 +582,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyInstanceNodeNumResult> ModifyInstanceNodeNumOutcome;
 			typedef std::future<ModifyInstanceNodeNumOutcome> ModifyInstanceNodeNumOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::ModifyInstanceNodeNumRequest&, const ModifyInstanceNodeNumOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceNodeNumAsyncHandler;
+			typedef Outcome<Error, Model::ModifyInstanceSSLResult> ModifyInstanceSSLOutcome;
+			typedef std::future<ModifyInstanceSSLOutcome> ModifyInstanceSSLOutcomeCallable;
+			typedef std::function<void(const OceanBaseProClient*, const Model::ModifyInstanceSSLRequest&, const ModifyInstanceSSLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceSSLAsyncHandler;
 			typedef Outcome<Error, Model::ModifyInstanceSpecResult> ModifyInstanceSpecOutcome;
 			typedef std::future<ModifyInstanceSpecOutcome> ModifyInstanceSpecOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::ModifyInstanceSpecRequest&, const ModifyInstanceSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceSpecAsyncHandler;
@@ -889,6 +899,9 @@ namespace AlibabaCloud
 			DescribeTenantMetricsOutcome describeTenantMetrics(const Model::DescribeTenantMetricsRequest &request)const;
 			void describeTenantMetricsAsync(const Model::DescribeTenantMetricsRequest& request, const DescribeTenantMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeTenantMetricsOutcomeCallable describeTenantMetricsCallable(const Model::DescribeTenantMetricsRequest& request) const;
+			DescribeTenantReadableScnOutcome describeTenantReadableScn(const Model::DescribeTenantReadableScnRequest &request)const;
+			void describeTenantReadableScnAsync(const Model::DescribeTenantReadableScnRequest& request, const DescribeTenantReadableScnAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeTenantReadableScnOutcomeCallable describeTenantReadableScnCallable(const Model::DescribeTenantReadableScnRequest& request) const;
 			DescribeTenantSecurityConfigsOutcome describeTenantSecurityConfigs(const Model::DescribeTenantSecurityConfigsRequest &request)const;
 			void describeTenantSecurityConfigsAsync(const Model::DescribeTenantSecurityConfigsRequest& request, const DescribeTenantSecurityConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeTenantSecurityConfigsOutcomeCallable describeTenantSecurityConfigsCallable(const Model::DescribeTenantSecurityConfigsRequest& request) const;
@@ -955,6 +968,9 @@ namespace AlibabaCloud
 			ModifyInstanceNodeNumOutcome modifyInstanceNodeNum(const Model::ModifyInstanceNodeNumRequest &request)const;
 			void modifyInstanceNodeNumAsync(const Model::ModifyInstanceNodeNumRequest& request, const ModifyInstanceNodeNumAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyInstanceNodeNumOutcomeCallable modifyInstanceNodeNumCallable(const Model::ModifyInstanceNodeNumRequest& request) const;
+			ModifyInstanceSSLOutcome modifyInstanceSSL(const Model::ModifyInstanceSSLRequest &request)const;
+			void modifyInstanceSSLAsync(const Model::ModifyInstanceSSLRequest& request, const ModifyInstanceSSLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyInstanceSSLOutcomeCallable modifyInstanceSSLCallable(const Model::ModifyInstanceSSLRequest& request) const;
 			ModifyInstanceSpecOutcome modifyInstanceSpec(const Model::ModifyInstanceSpecRequest &request)const;
 			void modifyInstanceSpecAsync(const Model::ModifyInstanceSpecRequest& request, const ModifyInstanceSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyInstanceSpecOutcomeCallable modifyInstanceSpecCallable(const Model::ModifyInstanceSpecRequest& request) const;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h

@@ -32,11 +32,14 @@ public:
 	~DescribeInstanceRequest();
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
+	std::string getMaxConnectionLimit() const;
+	void setMaxConnectionLimit(const std::string &maxConnectionLimit);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 
 private:
 	int pageNumber_;
+	std::string maxConnectionLimit_;
 	std::string instanceId_;
 };
 } // namespace Model

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h

@@ -154,9 +154,11 @@ namespace AlibabaCloud
 					std::string nodeNum;
 					bool enableIsolationOptimization;
 					std::string dataMergeTime;
+					std::string specType;
 					bool inTempCapacityStatus;
 					bool enableReadOnlyReplica;
 					std::string primaryInstance;
+					bool allowModifyInternetAddressConnectionLimit;
 					bool isTrustEcs;
 					std::string proxyClusterId;
 					bool isLatestObVersion;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h

@@ -52,17 +52,22 @@ namespace AlibabaCloud
 								bool manualMigrate;
 							};
 							std::string tenantZoneRole;
+							std::string replicaType;
 							bool isPrimaryTenantZone;
 							std::string tenantZoneId;
+							std::string logicalZone;
 							std::vector<TenantZonesItem::UnitsItem> units;
 						};
+						float tenantDiskSize;
+						std::string tenantName;
 						std::string primaryZoneDeployType;
 						std::string tenantId;
 						std::string tenantStatus;
-						std::string tenantName;
 						float tenantMemory;
 						std::vector<TenantsItem::TenantZonesItem> tenantZones;
 						int tenantUnitNum;
+						float tenantUnitMemory;
+						float tenantUnitCpu;
 						float tenantCpu;
 						std::string tenantDeployType;
 						std::string tenantMode;
@@ -104,6 +109,7 @@ namespace AlibabaCloud
 							std::vector<NodesItem::NodeResourceItem> nodeResource;
 							std::string replicaType;
 							std::string nodeId;
+							std::string logicalZone;
 							long readOnlyCopyId;
 							std::string nodeStatus;
 							long fullCopyId;
@@ -115,7 +121,40 @@ namespace AlibabaCloud
 						std::string zoneDisk;
 						std::vector<ZonesItem::NodesItem> nodes;
 					};
+					struct ReplicasItem
+					{
+						struct ReplicaResource
+						{
+							struct Memory2
+							{
+								long usedMemory;
+								long totalMemory;
+							};
+							struct DiskSize3
+							{
+								float usedDiskSize;
+								long totalDiskSize;
+							};
+							struct Cpu4
+							{
+								int totalCpu;
+								int usedCpu;
+							};
+							DiskSize3 diskSize3;
+							Memory2 memory2;
+							Cpu4 cpu4;
+						};
+						int zoneLogicalId;
+						std::string status;
+						ReplicaResource replicaResource;
+						int nodeNum;
+						std::string replicaType;
+						std::string logicalZone;
+						std::string zoneRegionName;
+						std::string zoneLogicalName;
+					};
 					std::vector<TenantsItem> tenants;
+					std::vector<ReplicasItem> replicas;
 					std::vector<ZonesItem> zones;
 				};
 

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h

@@ -82,6 +82,7 @@ namespace AlibabaCloud
 					};
 					std::string deployType;
 					std::string resourceGroupId;
+					std::string specType;
 					bool enableUpgradeNodes;
 					long usedDiskSize;
 					int cpu;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSlowSQLListResult.h

@@ -154,7 +154,7 @@ namespace AlibabaCloud
 					double avgCpuTime;
 					double sumDbTime;
 					double strongConsistencyPercentage;
-					double retCode4013Count;
+					long retCode4013Count;
 					double avgConcurrencyWaitTime;
 					double avgBlockIndexCacheHit;
 					double sumElapsedTime;
@@ -187,7 +187,7 @@ namespace AlibabaCloud
 					double missPlanPercentage;
 					std::string waitEvent;
 					double totalWaitTime;
-					double retCode4012Count;
+					long retCode4012Count;
 					double avgElapsedTime;
 					double failPercentage;
 					double maxReturnRows;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantReadableScnRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTREADABLESCNREQUEST_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTREADABLESCNREQUEST_H_
+
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace OceanBasePro {
+namespace Model {
+class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeTenantReadableScnRequest : public RpcServiceRequest {
+public:
+	DescribeTenantReadableScnRequest();
+	~DescribeTenantReadableScnRequest();
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getTenantId() const;
+	void setTenantId(const std::string &tenantId);
+
+private:
+	std::string instanceId_;
+	std::string tenantId_;
+};
+} // namespace Model
+} // namespace OceanBasePro
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTREADABLESCNREQUEST_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantReadableScnResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h

@@ -111,20 +111,27 @@ namespace AlibabaCloud
 						std::string intranetAddressStatus;
 						std::vector<std::string> connectionZones;
 						std::string internetAddress;
-						std::string connectionReplicaType;
 						std::string intranetAddressSlaveZoneId;
-						std::string internetAddressStatus;
-						long maxConnectionNum;
-						std::string vSwitchId;
-						std::string tenantEndpointId;
-						std::string intranetAddressMasterZoneId;
+						long internetMaxConnectionNum;
 						int internetPort;
 						bool transactionSplit;
 						bool enableTransactionSplit;
+						std::string proxyClusterId;
 						int intranetPort;
 						long parallelQueryDegree;
+						int internetRpcPort;
+						std::string connectionReplicaType;
+						std::string internetAddressStatus;
+						long maxConnectionNum;
+						long maxConnectionLimit;
+						std::string vSwitchId;
+						std::string tenantEndpointId;
+						std::string intranetAddressMasterZoneId;
+						long internetMaxConnectionLimit;
+						int intranetRpcPort;
 						std::string intranetAddress;
 						std::string vpcId;
+						std::vector<std::string> connectionLogicalZones;
 						std::string addressType;
 					};
 					struct TenantZonesItem
@@ -161,6 +168,7 @@ namespace AlibabaCloud
 					std::string tenantMode;
 					std::string lowerCaseTableNames;
 					std::string status;
+					std::string recycleBinStatus;
 					bool enableClogService;
 					std::string tenantName;
 					bool enableParallelQuery;

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCESSLREQUEST_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCESSLREQUEST_H_
+
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace OceanBasePro {
+namespace Model {
+class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyInstanceSSLRequest : public RpcServiceRequest {
+public:
+	ModifyInstanceSSLRequest();
+	~ModifyInstanceSSLRequest();
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getEnableSSL() const;
+	void setEnableSSL(const std::string &enableSSL);
+
+private:
+	std::string instanceId_;
+	std::string enableSSL_;
+};
+} // namespace Model
+} // namespace OceanBasePro
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCESSLREQUEST_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h

@@ -0,0 +1,56 @@
+/*
+ * 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_MODIFYINSTANCESSLRESULT_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCESSLRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OceanBasePro
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyInstanceSSLResult : public ServiceResult
+			{
+			public:
+				struct InstanceSSL
+				{
+					std::string enableSSL;
+					std::string instanceId;
+				};
+
+
+				ModifyInstanceSSLResult();
+				explicit ModifyInstanceSSLResult(const std::string &payload);
+				~ModifyInstanceSSLResult();
+				InstanceSSL getInstanceSSL()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				InstanceSSL instanceSSL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCESSLRESULT_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h

@@ -44,6 +44,8 @@ public:
 	void setInstanceId(const std::string &instanceId);
 	long getLogDiskSize() const;
 	void setLogDiskSize(long logDiskSize);
+	bool getUpgradeSpecNative() const;
+	void setUpgradeSpecNative(bool upgradeSpecNative);
 
 private:
 	bool autoUseCoupon_;
@@ -53,6 +55,7 @@ private:
 	std::string diskType_;
 	std::string instanceId_;
 	long logDiskSize_;
+	bool upgradeSpecNative_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/src/OceanBaseProClient.cc

@@ -2787,6 +2787,42 @@ OceanBaseProClient::DescribeTenantMetricsOutcomeCallable OceanBaseProClient::des
 	return task->get_future();
 }
 
+OceanBaseProClient::DescribeTenantReadableScnOutcome OceanBaseProClient::describeTenantReadableScn(const DescribeTenantReadableScnRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeTenantReadableScnOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeTenantReadableScnOutcome(DescribeTenantReadableScnResult(outcome.result()));
+	else
+		return DescribeTenantReadableScnOutcome(outcome.error());
+}
+
+void OceanBaseProClient::describeTenantReadableScnAsync(const DescribeTenantReadableScnRequest& request, const DescribeTenantReadableScnAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeTenantReadableScn(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OceanBaseProClient::DescribeTenantReadableScnOutcomeCallable OceanBaseProClient::describeTenantReadableScnCallable(const DescribeTenantReadableScnRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeTenantReadableScnOutcome()>>(
+			[this, request]()
+			{
+			return this->describeTenantReadableScn(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OceanBaseProClient::DescribeTenantSecurityConfigsOutcome OceanBaseProClient::describeTenantSecurityConfigs(const DescribeTenantSecurityConfigsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3579,6 +3615,42 @@ OceanBaseProClient::ModifyInstanceNodeNumOutcomeCallable OceanBaseProClient::mod
 	return task->get_future();
 }
 
+OceanBaseProClient::ModifyInstanceSSLOutcome OceanBaseProClient::modifyInstanceSSL(const ModifyInstanceSSLRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyInstanceSSLOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyInstanceSSLOutcome(ModifyInstanceSSLResult(outcome.result()));
+	else
+		return ModifyInstanceSSLOutcome(outcome.error());
+}
+
+void OceanBaseProClient::modifyInstanceSSLAsync(const ModifyInstanceSSLRequest& request, const ModifyInstanceSSLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyInstanceSSL(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OceanBaseProClient::ModifyInstanceSSLOutcomeCallable OceanBaseProClient::modifyInstanceSSLCallable(const ModifyInstanceSSLRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyInstanceSSLOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyInstanceSSL(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OceanBaseProClient::ModifyInstanceSpecOutcome OceanBaseProClient::modifyInstanceSpec(const ModifyInstanceSpecRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

oceanbasepro/src/model/DescribeInstanceRequest.cc

@@ -34,6 +34,15 @@ void DescribeInstanceRequest::setPageNumber(int pageNumber) {
   setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
+std::string DescribeInstanceRequest::getMaxConnectionLimit() const {
+  return maxConnectionLimit_;
+}
+
+void DescribeInstanceRequest::setMaxConnectionLimit(const std::string &maxConnectionLimit) {
+  maxConnectionLimit_ = maxConnectionLimit;
+  setBodyParameter(std::string("MaxConnectionLimit"), maxConnectionLimit);
+}
+
 std::string DescribeInstanceRequest::getInstanceId() const {
   return instanceId_;
 }

oceanbasepro/src/model/DescribeInstanceResult.cc

@@ -116,6 +116,10 @@ void DescribeInstanceResult::parse(const std::string &payload)
 		instance_.primaryInstance = instanceNode["PrimaryInstance"].asString();
 	if(!instanceNode["PrimaryRegion"].isNull())
 		instance_.primaryRegion = instanceNode["PrimaryRegion"].asString();
+	if(!instanceNode["SpecType"].isNull())
+		instance_.specType = instanceNode["SpecType"].asString();
+	if(!instanceNode["AllowModifyInternetAddressConnectionLimit"].isNull())
+		instance_.allowModifyInternetAddressConnectionLimit = instanceNode["AllowModifyInternetAddressConnectionLimit"].asString() == "true";
 	auto resourceNode = instanceNode["Resource"];
 	if(!resourceNode["UnitCount"].isNull())
 		instance_.resource.unitCount = std::stol(resourceNode["UnitCount"].asString());

oceanbasepro/src/model/DescribeInstanceTopologyResult.cc

@@ -62,6 +62,12 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 			tenantsItemObject.tenantUnitNum = std::stoi(instanceTopologyNodeTenantsTenantsItem["TenantUnitNum"].asString());
 		if(!instanceTopologyNodeTenantsTenantsItem["PrimaryZoneDeployType"].isNull())
 			tenantsItemObject.primaryZoneDeployType = instanceTopologyNodeTenantsTenantsItem["PrimaryZoneDeployType"].asString();
+		if(!instanceTopologyNodeTenantsTenantsItem["TenantDiskSize"].isNull())
+			tenantsItemObject.tenantDiskSize = std::stof(instanceTopologyNodeTenantsTenantsItem["TenantDiskSize"].asString());
+		if(!instanceTopologyNodeTenantsTenantsItem["TenantUnitCpu"].isNull())
+			tenantsItemObject.tenantUnitCpu = std::stof(instanceTopologyNodeTenantsTenantsItem["TenantUnitCpu"].asString());
+		if(!instanceTopologyNodeTenantsTenantsItem["TenantUnitMemory"].isNull())
+			tenantsItemObject.tenantUnitMemory = std::stof(instanceTopologyNodeTenantsTenantsItem["TenantUnitMemory"].asString());
 		auto allTenantZonesNode = instanceTopologyNodeTenantsTenantsItem["TenantZones"]["TenantZonesItem"];
 		for (auto instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem : allTenantZonesNode)
 		{
@@ -72,6 +78,10 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 				tenantZonesObject.isPrimaryTenantZone = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["IsPrimaryTenantZone"].asString() == "true";
 			if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["TenantZoneId"].isNull())
 				tenantZonesObject.tenantZoneId = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["TenantZoneId"].asString();
+			if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["LogicalZone"].isNull())
+				tenantZonesObject.logicalZone = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["LogicalZone"].asString();
+			if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReplicaType"].isNull())
+				tenantZonesObject.replicaType = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReplicaType"].asString();
 			auto allUnitsNode = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["Units"]["UnitsItem"];
 			for (auto instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem : allUnitsNode)
 			{
@@ -128,6 +138,8 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 				nodesObject.fullCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["FullCopyId"].asString());
 			if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyCopyId"].isNull())
 				nodesObject.readOnlyCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyCopyId"].asString());
+			if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["LogicalZone"].isNull())
+				nodesObject.logicalZone = instanceTopologyNodeZonesZonesItemNodesNodesItem["LogicalZone"].asString();
 			auto allNodeResourceNode = instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeResource"]["NodeResourceItem"];
 			for (auto instanceTopologyNodeZonesZonesItemNodesNodesItemNodeResourceNodeResourceItem : allNodeResourceNode)
 			{
@@ -160,6 +172,42 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 				zonesItemObject.zoneResource.diskSize1.maxDiskUsedObServer.push_back(value.asString());
 		instanceTopology_.zones.push_back(zonesItemObject);
 	}
+	auto allReplicasNode = instanceTopologyNode["Replicas"]["ReplicasItem"];
+	for (auto instanceTopologyNodeReplicasReplicasItem : allReplicasNode)
+	{
+		InstanceTopology::ReplicasItem replicasItemObject;
+		if(!instanceTopologyNodeReplicasReplicasItem["LogicalZone"].isNull())
+			replicasItemObject.logicalZone = instanceTopologyNodeReplicasReplicasItem["LogicalZone"].asString();
+		if(!instanceTopologyNodeReplicasReplicasItem["NodeNum"].isNull())
+			replicasItemObject.nodeNum = std::stoi(instanceTopologyNodeReplicasReplicasItem["NodeNum"].asString());
+		if(!instanceTopologyNodeReplicasReplicasItem["ZoneLogicalName"].isNull())
+			replicasItemObject.zoneLogicalName = instanceTopologyNodeReplicasReplicasItem["ZoneLogicalName"].asString();
+		if(!instanceTopologyNodeReplicasReplicasItem["ZoneRegionName"].isNull())
+			replicasItemObject.zoneRegionName = instanceTopologyNodeReplicasReplicasItem["ZoneRegionName"].asString();
+		if(!instanceTopologyNodeReplicasReplicasItem["ZoneLogicalId"].isNull())
+			replicasItemObject.zoneLogicalId = std::stoi(instanceTopologyNodeReplicasReplicasItem["ZoneLogicalId"].asString());
+		if(!instanceTopologyNodeReplicasReplicasItem["ReplicaType"].isNull())
+			replicasItemObject.replicaType = instanceTopologyNodeReplicasReplicasItem["ReplicaType"].asString();
+		if(!instanceTopologyNodeReplicasReplicasItem["Status"].isNull())
+			replicasItemObject.status = instanceTopologyNodeReplicasReplicasItem["Status"].asString();
+		auto replicaResourceNode = value["ReplicaResource"];
+		auto memory2Node = replicaResourceNode["Memory"];
+		if(!memory2Node["UsedMemory"].isNull())
+			replicasItemObject.replicaResource.memory2.usedMemory = std::stol(memory2Node["UsedMemory"].asString());
+		if(!memory2Node["TotalMemory"].isNull())
+			replicasItemObject.replicaResource.memory2.totalMemory = std::stol(memory2Node["TotalMemory"].asString());
+		auto diskSize3Node = replicaResourceNode["DiskSize"];
+		if(!diskSize3Node["UsedDiskSize"].isNull())
+			replicasItemObject.replicaResource.diskSize3.usedDiskSize = std::stof(diskSize3Node["UsedDiskSize"].asString());
+		if(!diskSize3Node["TotalDiskSize"].isNull())
+			replicasItemObject.replicaResource.diskSize3.totalDiskSize = std::stol(diskSize3Node["TotalDiskSize"].asString());
+		auto cpu4Node = replicaResourceNode["Cpu"];
+		if(!cpu4Node["TotalCpu"].isNull())
+			replicasItemObject.replicaResource.cpu4.totalCpu = std::stoi(cpu4Node["TotalCpu"].asString());
+		if(!cpu4Node["UsedCpu"].isNull())
+			replicasItemObject.replicaResource.cpu4.usedCpu = std::stoi(cpu4Node["UsedCpu"].asString());
+		instanceTopology_.replicas.push_back(replicasItemObject);
+	}
 
 }
 

oceanbasepro/src/model/DescribeInstancesResult.cc

@@ -97,6 +97,8 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.inTempCapacityStatus = valueInstancesData["InTempCapacityStatus"].asString() == "true";
 		if(!valueInstancesData["EnableReadOnlyReplicaManagement"].isNull())
 			instancesObject.enableReadOnlyReplicaManagement = valueInstancesData["EnableReadOnlyReplicaManagement"].asString() == "true";
+		if(!valueInstancesData["SpecType"].isNull())
+			instancesObject.specType = valueInstancesData["SpecType"].asString();
 		auto resourceNode = value["Resource"];
 		if(!resourceNode["UnitCount"].isNull())
 			instancesObject.resource.unitCount = std::stol(resourceNode["UnitCount"].asString());

oceanbasepro/src/model/DescribeOasSlowSQLListResult.cc

@@ -66,9 +66,9 @@ void DescribeOasSlowSQLListResult::parse(const std::string &payload)
 		if(!valueDataDataItem["DbName"].isNull())
 			dataObject.dbName = valueDataDataItem["DbName"].asString();
 		if(!valueDataDataItem["RetCode4012Count"].isNull())
-			dataObject.retCode4012Count = valueDataDataItem["RetCode4012Count"].asString();
+			dataObject.retCode4012Count = std::stol(valueDataDataItem["RetCode4012Count"].asString());
 		if(!valueDataDataItem["RetCode4013Count"].isNull())
-			dataObject.retCode4013Count = valueDataDataItem["RetCode4013Count"].asString();
+			dataObject.retCode4013Count = std::stol(valueDataDataItem["RetCode4013Count"].asString());
 		if(!valueDataDataItem["RetCode5001Count"].isNull())
 			dataObject.retCode5001Count = valueDataDataItem["RetCode5001Count"].asString();
 		if(!valueDataDataItem["RetCode5024Count"].isNull())

oceanbasepro/src/model/DescribeTenantReadableScnRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/oceanbasepro/model/DescribeTenantReadableScnRequest.h>
+
+using AlibabaCloud::OceanBasePro::Model::DescribeTenantReadableScnRequest;
+
+DescribeTenantReadableScnRequest::DescribeTenantReadableScnRequest()
+    : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeTenantReadableScn") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeTenantReadableScnRequest::~DescribeTenantReadableScnRequest() {}
+
+std::string DescribeTenantReadableScnRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeTenantReadableScnRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setBodyParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string DescribeTenantReadableScnRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void DescribeTenantReadableScnRequest::setTenantId(const std::string &tenantId) {
+  tenantId_ = tenantId;
+  setBodyParameter(std::string("TenantId"), tenantId);
+}
+

oceanbasepro/src/model/DescribeTenantReadableScnResult.cc

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

oceanbasepro/src/model/DescribeTenantResult.cc

@@ -96,6 +96,8 @@ void DescribeTenantResult::parse(const std::string &payload)
 		tenant_.dataMergeTime = tenantNode["DataMergeTime"].asString();
 	if(!tenantNode["EnableReadOnlyReplica"].isNull())
 		tenant_.enableReadOnlyReplica = tenantNode["EnableReadOnlyReplica"].asString() == "true";
+	if(!tenantNode["RecycleBinStatus"].isNull())
+		tenant_.recycleBinStatus = tenantNode["RecycleBinStatus"].asString();
 	if(!tenantNode["LowerCaseTableNames"].isNull())
 		tenant_.lowerCaseTableNames = tenantNode["LowerCaseTableNames"].asString();
 	if(!tenantNode["Version"].isNull())
@@ -138,9 +140,24 @@ void DescribeTenantResult::parse(const std::string &payload)
 			tenantConnectionsItemObject.maxConnectionNum = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].asString());
 		if(!tenantNodeTenantConnectionsTenantConnectionsItem["ConnectionReplicaType"].isNull())
 			tenantConnectionsItemObject.connectionReplicaType = tenantNodeTenantConnectionsTenantConnectionsItem["ConnectionReplicaType"].asString();
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["ProxyClusterId"].isNull())
+			tenantConnectionsItemObject.proxyClusterId = tenantNodeTenantConnectionsTenantConnectionsItem["ProxyClusterId"].asString();
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionLimit"].isNull())
+			tenantConnectionsItemObject.maxConnectionLimit = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionLimit"].asString());
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["InternetMaxConnectionLimit"].isNull())
+			tenantConnectionsItemObject.internetMaxConnectionLimit = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["InternetMaxConnectionLimit"].asString());
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["IntranetRpcPort"].isNull())
+			tenantConnectionsItemObject.intranetRpcPort = std::stoi(tenantNodeTenantConnectionsTenantConnectionsItem["IntranetRpcPort"].asString());
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["InternetMaxConnectionNum"].isNull())
+			tenantConnectionsItemObject.internetMaxConnectionNum = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["InternetMaxConnectionNum"].asString());
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["InternetRpcPort"].isNull())
+			tenantConnectionsItemObject.internetRpcPort = std::stoi(tenantNodeTenantConnectionsTenantConnectionsItem["InternetRpcPort"].asString());
 		auto allConnectionZones = value["ConnectionZones"]["ConnectionZones"];
 		for (auto value : allConnectionZones)
 			tenantConnectionsItemObject.connectionZones.push_back(value.asString());
+		auto allConnectionLogicalZones = value["ConnectionLogicalZones"]["ConnectionLogicalZones"];
+		for (auto value : allConnectionLogicalZones)
+			tenantConnectionsItemObject.connectionLogicalZones.push_back(value.asString());
 		tenant_.tenantConnections.push_back(tenantConnectionsItemObject);
 	}
 	auto allTenantZonesNode = tenantNode["TenantZones"]["TenantZonesItem"];

oceanbasepro/src/model/ModifyInstanceSSLRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h>
+
+using AlibabaCloud::OceanBasePro::Model::ModifyInstanceSSLRequest;
+
+ModifyInstanceSSLRequest::ModifyInstanceSSLRequest()
+    : RpcServiceRequest("oceanbasepro", "2019-09-01", "ModifyInstanceSSL") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyInstanceSSLRequest::~ModifyInstanceSSLRequest() {}
+
+std::string ModifyInstanceSSLRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void ModifyInstanceSSLRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setBodyParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string ModifyInstanceSSLRequest::getEnableSSL() const {
+  return enableSSL_;
+}
+
+void ModifyInstanceSSLRequest::setEnableSSL(const std::string &enableSSL) {
+  enableSSL_ = enableSSL;
+  setBodyParameter(std::string("EnableSSL"), enableSSL);
+}
+

oceanbasepro/src/model/ModifyInstanceSSLResult.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 <alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OceanBasePro;
+using namespace AlibabaCloud::OceanBasePro::Model;
+
+ModifyInstanceSSLResult::ModifyInstanceSSLResult() :
+	ServiceResult()
+{}
+
+ModifyInstanceSSLResult::ModifyInstanceSSLResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyInstanceSSLResult::~ModifyInstanceSSLResult()
+{}
+
+void ModifyInstanceSSLResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto instanceSSLNode = value["InstanceSSL"];
+	if(!instanceSSLNode["InstanceId"].isNull())
+		instanceSSL_.instanceId = instanceSSLNode["InstanceId"].asString();
+	if(!instanceSSLNode["EnableSSL"].isNull())
+		instanceSSL_.enableSSL = instanceSSLNode["EnableSSL"].asString();
+
+}
+
+ModifyInstanceSSLResult::InstanceSSL ModifyInstanceSSLResult::getInstanceSSL()const
+{
+	return instanceSSL_;
+}
+

oceanbasepro/src/model/ModifyInstanceSpecRequest.cc

@@ -88,3 +88,12 @@ void ModifyInstanceSpecRequest::setLogDiskSize(long logDiskSize) {
   setBodyParameter(std::string("LogDiskSize"), std::to_string(logDiskSize));
 }
 
+bool ModifyInstanceSpecRequest::getUpgradeSpecNative() const {
+  return upgradeSpecNative_;
+}
+
+void ModifyInstanceSpecRequest::setUpgradeSpecNative(bool upgradeSpecNative) {
+  upgradeSpecNative_ = upgradeSpecNative;
+  setBodyParameter(std::string("UpgradeSpecNative"), upgradeSpecNative ? "true" : "false");
+}
+