From 0d265770f78295891d06c4ddc027683cb76163ed Mon Sep 17 00:00:00 2001 From: sdk-team Date: Thu, 28 Dec 2023 11:31:26 +0000 Subject: [PATCH] Generated 2019-09-01 for OceanBasePro. --- VERSION | 2 +- .../model/CreateInstanceRequest.h | 6 ++ .../model/CreateTenantUserResult.h | 8 +-- .../model/DescribeAvailableSpecResult.h | 1 + .../model/DescribeInstanceResult.h | 50 ++++++++++++++++ .../model/DescribeInstanceTopologyResult.h | 4 ++ .../model/DescribeMetricsDataRequest.h | 3 + .../oceanbasepro/model/DescribeTenantResult.h | 49 +++++++++++++++ .../model/ModifyInstanceSpecRequest.h | 3 + .../ModifyInstanceTemporaryCapacityRequest.h | 3 + .../model/ModifyTenantPrimaryZoneRequest.h | 6 ++ .../src/model/CreateInstanceRequest.cc | 18 ++++++ .../src/model/CreateTenantUserResult.cc | 37 +++++------- .../src/model/DescribeAvailableSpecResult.cc | 3 + .../src/model/DescribeInstanceResult.cc | 60 +++++++++++++++++++ .../model/DescribeInstanceTopologyResult.cc | 8 +++ .../src/model/DescribeMetricsDataRequest.cc | 9 +++ .../src/model/DescribeTenantResult.cc | 54 +++++++++++++++++ .../src/model/ModifyInstanceSpecRequest.cc | 9 +++ .../ModifyInstanceTemporaryCapacityRequest.cc | 9 +++ .../model/ModifyTenantPrimaryZoneRequest.cc | 18 ++++++ 21 files changed, 334 insertions(+), 26 deletions(-) diff --git a/VERSION b/VERSION index 5eccfe487..133c43103 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1838 \ No newline at end of file +1.36.1839 \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h index ca222deaa..02b2d6257 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h @@ -60,6 +60,10 @@ public: void setAutoRenew(bool autoRenew); std::string getSeries() const; void setSeries(const std::string &series); + std::string getPrimaryInstance() const; + void setPrimaryInstance(const std::string &primaryInstance); + std::string getPrimaryRegion() const; + void setPrimaryRegion(const std::string &primaryRegion); std::string getChargeType() const; void setChargeType(const std::string &chargeType); std::string getBid() const; @@ -81,6 +85,8 @@ private: std::string replicaMode_; bool autoRenew_; std::string series_; + std::string primaryInstance_; + std::string primaryRegion_; std::string chargeType_; std::string bid_; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h index a22076033..deb715db1 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h @@ -32,7 +32,7 @@ namespace AlibabaCloud class ALIBABACLOUD_OCEANBASEPRO_EXPORT CreateTenantUserResult : public ServiceResult { public: - struct Data + struct TenantUser { struct RolesItem { @@ -40,7 +40,7 @@ namespace AlibabaCloud std::string database; }; std::string userName; - std::vector roles; + std::vector roles; std::string userType; std::string userStatus; }; @@ -49,12 +49,12 @@ namespace AlibabaCloud CreateTenantUserResult(); explicit CreateTenantUserResult(const std::string &payload); ~CreateTenantUserResult(); - std::vector getTenantUser()const; + TenantUser getTenantUser()const; protected: void parse(const std::string &payload); private: - std::vector tenantUser_; + TenantUser tenantUser_; }; } diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h index 710e63259..aba45a30f 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h @@ -50,6 +50,7 @@ namespace AlibabaCloud }; std::vector nodeNum; DiskSizeRange diskSizeRange; + std::vector diskTypes; std::string instanceClass; std::string spec; LogDiskSizeRange logDiskSizeRange; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h index 0fb86ba07..5c9ffdf06 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h @@ -65,6 +65,7 @@ namespace AlibabaCloud { std::string maxLogAssignedPercent; std::string logAssignedSize; + int originalTotalDiskSize; std::vector maxLogAssignedObServer; long unitDiskSize; long totalDiskSize; @@ -97,8 +98,57 @@ namespace AlibabaCloud long upperThreshold; bool autoScale; }; + struct ReadOnlyResource + { + struct Cpu1 + { + long unitCpu; + long totalCpu; + long usedCpu; + long originalTotalCpu; + }; + struct Memory2 + { + long usedMemory; + long unitMemory; + long totalMemory; + long originalTotalMemory; + }; + struct DiskSize3 + { + double dataUsedSize; + long originalTotalDiskSize; + long usedDiskSize; + double maxDiskUsedPercent; + double maxDiskSize; + long unitDiskSize; + long totalDiskSize; + std::vector maxDiskUsedObServer6; + }; + struct LogDiskSize4 + { + std::string maxLogAssignedPercent; + std::string logAssignedSize; + long unitDiskSize; + long totalDiskSize; + std::vector maxLogAssignedObServer7; + }; + struct CapacityUnit5 + { + std::string usedCapacityUnit; + int maxCapacityUnit; + int minCapacityUnit; + }; + LogDiskSize4 logDiskSize4; + long unitCount; + Cpu1 cpu1; + DiskSize3 diskSize3; + CapacityUnit5 capacityUnit5; + Memory2 memory2; + }; std::string deployType; std::string proxyServiceStatus; + ReadOnlyResource readOnlyResource; std::string nodeNum; bool enableIsolationOptimization; std::string dataMergeTime; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h index 98a3c24ee..8c6c4cb1f 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h @@ -44,6 +44,7 @@ namespace AlibabaCloud long unitDataSize; std::string unitId; float unitMemory; + std::string replicaType; bool enableMigrateUnit; bool enableCancelMigrateUnit; std::string nodeId; @@ -101,8 +102,11 @@ namespace AlibabaCloud Cpu cpu; }; std::vector nodeResource; + std::string replicaType; std::string nodeId; + long readOnlyCopyId; std::string nodeStatus; + long fullCopyId; long nodeCopyId; }; std::string zoneId; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeMetricsDataRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeMetricsDataRequest.h index 66fb9c88a..2d6e9b4e1 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeMetricsDataRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeMetricsDataRequest.h @@ -40,6 +40,8 @@ public: void setSortOrder(const std::string &sortOrder); std::string getSortMetricKey() const; void setSortMetricKey(const std::string &sortMetricKey); + std::string getReplicaType() const; + void setReplicaType(const std::string &replicaType); std::string getEndTime() const; void setEndTime(const std::string &endTime); std::string getLabels() const; @@ -55,6 +57,7 @@ private: std::string limit_; std::string sortOrder_; std::string sortMetricKey_; + std::string replicaType_; std::string endTime_; std::string labels_; std::string instanceId_; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h index fb555a12f..32ac4bfd0 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h @@ -70,11 +70,48 @@ namespace AlibabaCloud Cpu cpu; LogDiskSize logDiskSize; }; + struct ReadOnlyResource + { + struct Cpu1 + { + float unitCpu; + float totalCpu; + float usedCpu; + }; + struct Memory2 + { + float usedMemory; + float unitMemory; + float totalMemory; + }; + struct DiskSize3 + { + float usedDiskSize; + }; + struct CapacityUnit4 + { + int usedCapacit; + int maxCapacityUnit; + int minCapacityUnit; + }; + struct LogDiskSize5 + { + int totalLogDisk; + int unitLogDisk; + }; + LogDiskSize5 logDiskSize5; + int unitNum; + Cpu1 cpu1; + DiskSize3 diskSize3; + CapacityUnit4 capacityUnit4; + Memory2 memory2; + }; struct TenantConnectionsItem { std::string intranetAddressStatus; std::vector connectionZones; std::string internetAddress; + std::string connectionReplicaType; std::string intranetAddressSlaveZoneId; std::string internetAddressStatus; long maxConnectionNum; @@ -92,13 +129,25 @@ namespace AlibabaCloud }; struct TenantZonesItem { + struct TenantZoneReplicasItem + { + std::string zoneNodes; + int zoneCopyId; + std::string logicZoneName; + std::string readOnlyCopyId; + std::string zoneReplicaType; + int fullCopyId; + }; std::string tenantZoneRole; + std::vector tenantZoneReplicas; std::string tenantZoneId; std::string region; }; std::string deployType; + ReadOnlyResource readOnlyResource; std::string description; long maxParallelQueryDegree; + std::string dataMergeTime; std::string masterIntranetAddressZone; std::vector availableZones; std::string diskType; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h index 82c8ea84d..fe704eae8 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h @@ -38,6 +38,8 @@ public: void setDryRun(bool dryRun); long getDiskSize() const; void setDiskSize(long diskSize); + std::string getDiskType() const; + void setDiskType(const std::string &diskType); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); long getLogDiskSize() const; @@ -48,6 +50,7 @@ private: std::string instanceClass_; bool dryRun_; long diskSize_; + std::string diskType_; std::string instanceId_; long logDiskSize_; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h index 8caee2fce..9843c04b8 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h @@ -36,11 +36,14 @@ public: void setSpec(const std::string &spec); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); + std::string getAcceptLanguage() const; + void setAcceptLanguage(const std::string &acceptLanguage); private: std::string diskSize_; std::string spec_; std::string instanceId_; + std::string acceptLanguage_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantPrimaryZoneRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantPrimaryZoneRequest.h index 0ce9ea73b..3ea16bf50 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantPrimaryZoneRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantPrimaryZoneRequest.h @@ -30,6 +30,8 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyTenantPrimaryZoneRequest : public R public: ModifyTenantPrimaryZoneRequest(); ~ModifyTenantPrimaryZoneRequest(); + std::string getTenantEndpointDirectId() const; + void setTenantEndpointDirectId(const std::string &tenantEndpointDirectId); std::string getUserVSwitchId() const; void setUserVSwitchId(const std::string &userVSwitchId); std::string getMasterIntranetAddressZone() const; @@ -42,14 +44,18 @@ public: void setInstanceId(const std::string &instanceId); std::string getPrimaryZone() const; void setPrimaryZone(const std::string &primaryZone); + std::string getUserDirectVSwitchId() const; + void setUserDirectVSwitchId(const std::string &userDirectVSwitchId); private: + std::string tenantEndpointDirectId_; std::string userVSwitchId_; std::string masterIntranetAddressZone_; std::string tenantId_; std::string tenantEndpointId_; std::string instanceId_; std::string primaryZone_; + std::string userDirectVSwitchId_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/src/model/CreateInstanceRequest.cc b/oceanbasepro/src/model/CreateInstanceRequest.cc index 110391cf3..c26773331 100644 --- a/oceanbasepro/src/model/CreateInstanceRequest.cc +++ b/oceanbasepro/src/model/CreateInstanceRequest.cc @@ -160,6 +160,24 @@ void CreateInstanceRequest::setSeries(const std::string &series) { setBodyParameter(std::string("Series"), series); } +std::string CreateInstanceRequest::getPrimaryInstance() const { + return primaryInstance_; +} + +void CreateInstanceRequest::setPrimaryInstance(const std::string &primaryInstance) { + primaryInstance_ = primaryInstance; + setBodyParameter(std::string("PrimaryInstance"), primaryInstance); +} + +std::string CreateInstanceRequest::getPrimaryRegion() const { + return primaryRegion_; +} + +void CreateInstanceRequest::setPrimaryRegion(const std::string &primaryRegion) { + primaryRegion_ = primaryRegion; + setBodyParameter(std::string("PrimaryRegion"), primaryRegion); +} + std::string CreateInstanceRequest::getChargeType() const { return chargeType_; } diff --git a/oceanbasepro/src/model/CreateTenantUserResult.cc b/oceanbasepro/src/model/CreateTenantUserResult.cc index 6a619ac7f..d2eb536b1 100644 --- a/oceanbasepro/src/model/CreateTenantUserResult.cc +++ b/oceanbasepro/src/model/CreateTenantUserResult.cc @@ -39,32 +39,27 @@ void CreateTenantUserResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - auto allTenantUserNode = value["TenantUser"]["Data"]; - for (auto valueTenantUserData : allTenantUserNode) + auto tenantUserNode = value["TenantUser"]; + if(!tenantUserNode["UserType"].isNull()) + tenantUser_.userType = tenantUserNode["UserType"].asString(); + if(!tenantUserNode["UserStatus"].isNull()) + tenantUser_.userStatus = tenantUserNode["UserStatus"].asString(); + if(!tenantUserNode["UserName"].isNull()) + tenantUser_.userName = tenantUserNode["UserName"].asString(); + auto allRolesNode = tenantUserNode["Roles"]["RolesItem"]; + for (auto tenantUserNodeRolesRolesItem : allRolesNode) { - Data tenantUserObject; - if(!valueTenantUserData["UserType"].isNull()) - tenantUserObject.userType = valueTenantUserData["UserType"].asString(); - if(!valueTenantUserData["UserStatus"].isNull()) - tenantUserObject.userStatus = valueTenantUserData["UserStatus"].asString(); - if(!valueTenantUserData["UserName"].isNull()) - tenantUserObject.userName = valueTenantUserData["UserName"].asString(); - auto allRolesNode = valueTenantUserData["Roles"]["RolesItem"]; - for (auto valueTenantUserDataRolesRolesItem : allRolesNode) - { - Data::RolesItem rolesObject; - if(!valueTenantUserDataRolesRolesItem["Database"].isNull()) - rolesObject.database = valueTenantUserDataRolesRolesItem["Database"].asString(); - if(!valueTenantUserDataRolesRolesItem["Role"].isNull()) - rolesObject.role = valueTenantUserDataRolesRolesItem["Role"].asString(); - tenantUserObject.roles.push_back(rolesObject); - } - tenantUser_.push_back(tenantUserObject); + TenantUser::RolesItem rolesItemObject; + if(!tenantUserNodeRolesRolesItem["Database"].isNull()) + rolesItemObject.database = tenantUserNodeRolesRolesItem["Database"].asString(); + if(!tenantUserNodeRolesRolesItem["Role"].isNull()) + rolesItemObject.role = tenantUserNodeRolesRolesItem["Role"].asString(); + tenantUser_.roles.push_back(rolesItemObject); } } -std::vector CreateTenantUserResult::getTenantUser()const +CreateTenantUserResult::TenantUser CreateTenantUserResult::getTenantUser()const { return tenantUser_; } diff --git a/oceanbasepro/src/model/DescribeAvailableSpecResult.cc b/oceanbasepro/src/model/DescribeAvailableSpecResult.cc index 23da554f7..10cc61b01 100644 --- a/oceanbasepro/src/model/DescribeAvailableSpecResult.cc +++ b/oceanbasepro/src/model/DescribeAvailableSpecResult.cc @@ -65,6 +65,9 @@ void DescribeAvailableSpecResult::parse(const std::string &payload) auto allNodeNum = value["NodeNum"]["NodeNum"]; for (auto value : allNodeNum) availableSpecificationsItemObject.nodeNum.push_back(value.asString()); + auto allDiskTypes = value["DiskTypes"]["DiskTypes"]; + for (auto value : allDiskTypes) + availableSpecificationsItemObject.diskTypes.push_back(value.asString()); data_.availableSpecifications.push_back(availableSpecificationsItemObject); } diff --git a/oceanbasepro/src/model/DescribeInstanceResult.cc b/oceanbasepro/src/model/DescribeInstanceResult.cc index 0f38e3353..f047c092f 100644 --- a/oceanbasepro/src/model/DescribeInstanceResult.cc +++ b/oceanbasepro/src/model/DescribeInstanceResult.cc @@ -150,6 +150,8 @@ void DescribeInstanceResult::parse(const std::string &payload) instance_.resource.logDiskSize.logAssignedSize = logDiskSizeNode["LogAssignedSize"].asString(); if(!logDiskSizeNode["MaxLogAssignedPercent"].isNull()) instance_.resource.logDiskSize.maxLogAssignedPercent = logDiskSizeNode["MaxLogAssignedPercent"].asString(); + if(!logDiskSizeNode["OriginalTotalDiskSize"].isNull()) + instance_.resource.logDiskSize.originalTotalDiskSize = std::stoi(logDiskSizeNode["OriginalTotalDiskSize"].asString()); auto allMaxLogAssignedObServer = logDiskSizeNode["MaxLogAssignedObServer"]["MaxLogAssignedObServer"]; for (auto value : allMaxLogAssignedObServer) instance_.resource.logDiskSize.maxLogAssignedObServer.push_back(value.asString()); @@ -180,6 +182,64 @@ void DescribeInstanceResult::parse(const std::string &payload) instance_.dataDiskAutoScaleConfig.scaleStepInNormal = std::stol(dataDiskAutoScaleConfigNode["ScaleStepInNormal"].asString()); if(!dataDiskAutoScaleConfigNode["ScaleStepInMerge"].isNull()) instance_.dataDiskAutoScaleConfig.scaleStepInMerge = std::stol(dataDiskAutoScaleConfigNode["ScaleStepInMerge"].asString()); + auto readOnlyResourceNode = instanceNode["ReadOnlyResource"]; + if(!readOnlyResourceNode["UnitCount"].isNull()) + instance_.readOnlyResource.unitCount = std::stol(readOnlyResourceNode["UnitCount"].asString()); + auto cpu1Node = readOnlyResourceNode["Cpu"]; + if(!cpu1Node["TotalCpu"].isNull()) + instance_.readOnlyResource.cpu1.totalCpu = std::stol(cpu1Node["TotalCpu"].asString()); + if(!cpu1Node["UsedCpu"].isNull()) + instance_.readOnlyResource.cpu1.usedCpu = std::stol(cpu1Node["UsedCpu"].asString()); + if(!cpu1Node["UnitCpu"].isNull()) + instance_.readOnlyResource.cpu1.unitCpu = std::stol(cpu1Node["UnitCpu"].asString()); + if(!cpu1Node["OriginalTotalCpu"].isNull()) + instance_.readOnlyResource.cpu1.originalTotalCpu = std::stol(cpu1Node["OriginalTotalCpu"].asString()); + auto memory2Node = readOnlyResourceNode["Memory"]; + if(!memory2Node["TotalMemory"].isNull()) + instance_.readOnlyResource.memory2.totalMemory = std::stol(memory2Node["TotalMemory"].asString()); + if(!memory2Node["UsedMemory"].isNull()) + instance_.readOnlyResource.memory2.usedMemory = std::stol(memory2Node["UsedMemory"].asString()); + if(!memory2Node["UnitMemory"].isNull()) + instance_.readOnlyResource.memory2.unitMemory = std::stol(memory2Node["UnitMemory"].asString()); + if(!memory2Node["OriginalTotalMemory"].isNull()) + instance_.readOnlyResource.memory2.originalTotalMemory = std::stol(memory2Node["OriginalTotalMemory"].asString()); + auto diskSize3Node = readOnlyResourceNode["DiskSize"]; + if(!diskSize3Node["TotalDiskSize"].isNull()) + instance_.readOnlyResource.diskSize3.totalDiskSize = std::stol(diskSize3Node["TotalDiskSize"].asString()); + if(!diskSize3Node["UsedDiskSize"].isNull()) + instance_.readOnlyResource.diskSize3.usedDiskSize = std::stol(diskSize3Node["UsedDiskSize"].asString()); + if(!diskSize3Node["UnitDiskSize"].isNull()) + instance_.readOnlyResource.diskSize3.unitDiskSize = std::stol(diskSize3Node["UnitDiskSize"].asString()); + if(!diskSize3Node["DataUsedSize"].isNull()) + instance_.readOnlyResource.diskSize3.dataUsedSize = diskSize3Node["DataUsedSize"].asString(); + if(!diskSize3Node["MaxDiskUsedPercent"].isNull()) + instance_.readOnlyResource.diskSize3.maxDiskUsedPercent = diskSize3Node["MaxDiskUsedPercent"].asString(); + if(!diskSize3Node["OriginalTotalDiskSize"].isNull()) + instance_.readOnlyResource.diskSize3.originalTotalDiskSize = std::stol(diskSize3Node["OriginalTotalDiskSize"].asString()); + if(!diskSize3Node["MaxDiskSize"].isNull()) + instance_.readOnlyResource.diskSize3.maxDiskSize = diskSize3Node["MaxDiskSize"].asString(); + auto allMaxDiskUsedObServer6 = diskSize3Node["MaxDiskUsedObServer"]["MaxDiskUsedObServer"]; + for (auto value : allMaxDiskUsedObServer6) + instance_.readOnlyResource.diskSize3.maxDiskUsedObServer6.push_back(value.asString()); + auto logDiskSize4Node = readOnlyResourceNode["LogDiskSize"]; + if(!logDiskSize4Node["TotalDiskSize"].isNull()) + instance_.readOnlyResource.logDiskSize4.totalDiskSize = std::stol(logDiskSize4Node["TotalDiskSize"].asString()); + if(!logDiskSize4Node["UnitDiskSize"].isNull()) + instance_.readOnlyResource.logDiskSize4.unitDiskSize = std::stol(logDiskSize4Node["UnitDiskSize"].asString()); + if(!logDiskSize4Node["LogAssignedSize"].isNull()) + instance_.readOnlyResource.logDiskSize4.logAssignedSize = logDiskSize4Node["LogAssignedSize"].asString(); + if(!logDiskSize4Node["MaxLogAssignedPercent"].isNull()) + instance_.readOnlyResource.logDiskSize4.maxLogAssignedPercent = logDiskSize4Node["MaxLogAssignedPercent"].asString(); + auto allMaxLogAssignedObServer7 = logDiskSize4Node["MaxLogAssignedObServer"]["MaxLogAssignedObServer"]; + for (auto value : allMaxLogAssignedObServer7) + instance_.readOnlyResource.logDiskSize4.maxLogAssignedObServer7.push_back(value.asString()); + auto capacityUnit5Node = readOnlyResourceNode["CapacityUnit"]; + if(!capacityUnit5Node["MaxCapacityUnit"].isNull()) + instance_.readOnlyResource.capacityUnit5.maxCapacityUnit = std::stoi(capacityUnit5Node["MaxCapacityUnit"].asString()); + if(!capacityUnit5Node["MinCapacityUnit"].isNull()) + instance_.readOnlyResource.capacityUnit5.minCapacityUnit = std::stoi(capacityUnit5Node["MinCapacityUnit"].asString()); + if(!capacityUnit5Node["UsedCapacityUnit"].isNull()) + instance_.readOnlyResource.capacityUnit5.usedCapacityUnit = capacityUnit5Node["UsedCapacityUnit"].asString(); auto allAvailableZones = instanceNode["AvailableZones"]["AvailableZones"]; for (auto value : allAvailableZones) instance_.availableZones.push_back(value.asString()); diff --git a/oceanbasepro/src/model/DescribeInstanceTopologyResult.cc b/oceanbasepro/src/model/DescribeInstanceTopologyResult.cc index fe47edc11..5282a7cb7 100644 --- a/oceanbasepro/src/model/DescribeInstanceTopologyResult.cc +++ b/oceanbasepro/src/model/DescribeInstanceTopologyResult.cc @@ -94,6 +94,8 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload) unitsObject.enableCancelMigrateUnit = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["EnableCancelMigrateUnit"].asString() == "true"; if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["UnitDataSize"].isNull()) unitsObject.unitDataSize = std::stol(instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["UnitDataSize"].asString()); + if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["ReplicaType"].isNull()) + unitsObject.replicaType = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["ReplicaType"].asString(); tenantZonesObject.units.push_back(unitsObject); } tenantsItemObject.tenantZones.push_back(tenantZonesObject); @@ -120,6 +122,12 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload) nodesObject.nodeCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeCopyId"].asString()); if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeStatus"].isNull()) nodesObject.nodeStatus = instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeStatus"].asString(); + if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["ReplicaType"].isNull()) + nodesObject.replicaType = instanceTopologyNodeZonesZonesItemNodesNodesItem["ReplicaType"].asString(); + if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["FullCopyId"].isNull()) + nodesObject.fullCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["FullCopyId"].asString()); + if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyCopyId"].isNull()) + nodesObject.readOnlyCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyCopyId"].asString()); auto allNodeResourceNode = instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeResource"]["NodeResourceItem"]; for (auto instanceTopologyNodeZonesZonesItemNodesNodesItemNodeResourceNodeResourceItem : allNodeResourceNode) { diff --git a/oceanbasepro/src/model/DescribeMetricsDataRequest.cc b/oceanbasepro/src/model/DescribeMetricsDataRequest.cc index aafba6179..742594676 100644 --- a/oceanbasepro/src/model/DescribeMetricsDataRequest.cc +++ b/oceanbasepro/src/model/DescribeMetricsDataRequest.cc @@ -70,6 +70,15 @@ void DescribeMetricsDataRequest::setSortMetricKey(const std::string &sortMetricK setParameter(std::string("SortMetricKey"), sortMetricKey); } +std::string DescribeMetricsDataRequest::getReplicaType() const { + return replicaType_; +} + +void DescribeMetricsDataRequest::setReplicaType(const std::string &replicaType) { + replicaType_ = replicaType; + setBodyParameter(std::string("ReplicaType"), replicaType); +} + std::string DescribeMetricsDataRequest::getEndTime() const { return endTime_; } diff --git a/oceanbasepro/src/model/DescribeTenantResult.cc b/oceanbasepro/src/model/DescribeTenantResult.cc index 03717bdf1..9a0787e10 100644 --- a/oceanbasepro/src/model/DescribeTenantResult.cc +++ b/oceanbasepro/src/model/DescribeTenantResult.cc @@ -92,6 +92,8 @@ void DescribeTenantResult::parse(const std::string &payload) tenant_.enableBinlogService = tenantNode["EnableBinlogService"].asString() == "true"; if(!tenantNode["TimeZone"].isNull()) tenant_.timeZone = tenantNode["TimeZone"].asString(); + if(!tenantNode["DataMergeTime"].isNull()) + tenant_.dataMergeTime = tenantNode["DataMergeTime"].asString(); auto allTenantConnectionsNode = tenantNode["TenantConnections"]["TenantConnectionsItem"]; for (auto tenantNodeTenantConnectionsTenantConnectionsItem : allTenantConnectionsNode) { @@ -128,6 +130,8 @@ void DescribeTenantResult::parse(const std::string &payload) tenantConnectionsItemObject.tenantEndpointId = tenantNodeTenantConnectionsTenantConnectionsItem["TenantEndpointId"].asString(); if(!tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].isNull()) tenantConnectionsItemObject.maxConnectionNum = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].asString()); + if(!tenantNodeTenantConnectionsTenantConnectionsItem["ConnectionReplicaType"].isNull()) + tenantConnectionsItemObject.connectionReplicaType = tenantNodeTenantConnectionsTenantConnectionsItem["ConnectionReplicaType"].asString(); auto allConnectionZones = value["ConnectionZones"]["ConnectionZones"]; for (auto value : allConnectionZones) tenantConnectionsItemObject.connectionZones.push_back(value.asString()); @@ -143,6 +147,24 @@ void DescribeTenantResult::parse(const std::string &payload) tenantZonesItemObject.region = tenantNodeTenantZonesTenantZonesItem["Region"].asString(); if(!tenantNodeTenantZonesTenantZonesItem["TenantZoneRole"].isNull()) tenantZonesItemObject.tenantZoneRole = tenantNodeTenantZonesTenantZonesItem["TenantZoneRole"].asString(); + auto allTenantZoneReplicasNode = tenantNodeTenantZonesTenantZonesItem["TenantZoneReplicas"]["TenantZoneReplicasItem"]; + for (auto tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem : allTenantZoneReplicasNode) + { + Tenant::TenantZonesItem::TenantZoneReplicasItem tenantZoneReplicasObject; + if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneReplicaType"].isNull()) + tenantZoneReplicasObject.zoneReplicaType = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneReplicaType"].asString(); + if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].isNull()) + tenantZoneReplicasObject.zoneNodes = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].asString(); + if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["LogicZoneName"].isNull()) + tenantZoneReplicasObject.logicZoneName = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["LogicZoneName"].asString(); + if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneCopyId"].isNull()) + tenantZoneReplicasObject.zoneCopyId = std::stoi(tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneCopyId"].asString()); + if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["FullCopyId"].isNull()) + tenantZoneReplicasObject.fullCopyId = std::stoi(tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["FullCopyId"].asString()); + if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyCopyId"].isNull()) + tenantZoneReplicasObject.readOnlyCopyId = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyCopyId"].asString(); + tenantZonesItemObject.tenantZoneReplicas.push_back(tenantZoneReplicasObject); + } tenant_.tenantZones.push_back(tenantZonesItemObject); } auto tenantResourceNode = tenantNode["TenantResource"]; @@ -177,6 +199,38 @@ void DescribeTenantResult::parse(const std::string &payload) tenant_.tenantResource.logDiskSize.totalLogDisk = std::stoi(logDiskSizeNode["TotalLogDisk"].asString()); if(!logDiskSizeNode["UnitLogDisk"].isNull()) tenant_.tenantResource.logDiskSize.unitLogDisk = std::stoi(logDiskSizeNode["UnitLogDisk"].asString()); + auto readOnlyResourceNode = tenantNode["ReadOnlyResource"]; + if(!readOnlyResourceNode["UnitNum"].isNull()) + tenant_.readOnlyResource.unitNum = std::stoi(readOnlyResourceNode["UnitNum"].asString()); + auto cpu1Node = readOnlyResourceNode["Cpu"]; + if(!cpu1Node["UsedCpu"].isNull()) + tenant_.readOnlyResource.cpu1.usedCpu = std::stof(cpu1Node["UsedCpu"].asString()); + if(!cpu1Node["TotalCpu"].isNull()) + tenant_.readOnlyResource.cpu1.totalCpu = std::stof(cpu1Node["TotalCpu"].asString()); + if(!cpu1Node["UnitCpu"].isNull()) + tenant_.readOnlyResource.cpu1.unitCpu = std::stof(cpu1Node["UnitCpu"].asString()); + auto memory2Node = readOnlyResourceNode["Memory"]; + if(!memory2Node["UsedMemory"].isNull()) + tenant_.readOnlyResource.memory2.usedMemory = std::stof(memory2Node["UsedMemory"].asString()); + if(!memory2Node["TotalMemory"].isNull()) + tenant_.readOnlyResource.memory2.totalMemory = std::stof(memory2Node["TotalMemory"].asString()); + if(!memory2Node["UnitMemory"].isNull()) + tenant_.readOnlyResource.memory2.unitMemory = std::stof(memory2Node["UnitMemory"].asString()); + auto diskSize3Node = readOnlyResourceNode["DiskSize"]; + if(!diskSize3Node["UsedDiskSize"].isNull()) + tenant_.readOnlyResource.diskSize3.usedDiskSize = std::stof(diskSize3Node["UsedDiskSize"].asString()); + auto capacityUnit4Node = readOnlyResourceNode["CapacityUnit"]; + if(!capacityUnit4Node["MaxCapacityUnit"].isNull()) + tenant_.readOnlyResource.capacityUnit4.maxCapacityUnit = std::stoi(capacityUnit4Node["MaxCapacityUnit"].asString()); + if(!capacityUnit4Node["MinCapacityUnit"].isNull()) + tenant_.readOnlyResource.capacityUnit4.minCapacityUnit = std::stoi(capacityUnit4Node["MinCapacityUnit"].asString()); + if(!capacityUnit4Node["UsedCapacit"].isNull()) + tenant_.readOnlyResource.capacityUnit4.usedCapacit = std::stoi(capacityUnit4Node["UsedCapacit"].asString()); + auto logDiskSize5Node = readOnlyResourceNode["LogDiskSize"]; + if(!logDiskSize5Node["TotalLogDisk"].isNull()) + tenant_.readOnlyResource.logDiskSize5.totalLogDisk = std::stoi(logDiskSize5Node["TotalLogDisk"].asString()); + if(!logDiskSize5Node["UnitLogDisk"].isNull()) + tenant_.readOnlyResource.logDiskSize5.unitLogDisk = std::stoi(logDiskSize5Node["UnitLogDisk"].asString()); auto allAvailableZones = tenantNode["AvailableZones"]["AvailableZones"]; for (auto value : allAvailableZones) tenant_.availableZones.push_back(value.asString()); diff --git a/oceanbasepro/src/model/ModifyInstanceSpecRequest.cc b/oceanbasepro/src/model/ModifyInstanceSpecRequest.cc index aa1d72e35..4a802ed05 100644 --- a/oceanbasepro/src/model/ModifyInstanceSpecRequest.cc +++ b/oceanbasepro/src/model/ModifyInstanceSpecRequest.cc @@ -61,6 +61,15 @@ void ModifyInstanceSpecRequest::setDiskSize(long diskSize) { setBodyParameter(std::string("DiskSize"), std::to_string(diskSize)); } +std::string ModifyInstanceSpecRequest::getDiskType() const { + return diskType_; +} + +void ModifyInstanceSpecRequest::setDiskType(const std::string &diskType) { + diskType_ = diskType; + setBodyParameter(std::string("DiskType"), diskType); +} + std::string ModifyInstanceSpecRequest::getInstanceId() const { return instanceId_; } diff --git a/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc b/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc index 6df879371..9c8136e89 100644 --- a/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc +++ b/oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc @@ -52,3 +52,12 @@ void ModifyInstanceTemporaryCapacityRequest::setInstanceId(const std::string &in setBodyParameter(std::string("InstanceId"), instanceId); } +std::string ModifyInstanceTemporaryCapacityRequest::getAcceptLanguage() const { + return acceptLanguage_; +} + +void ModifyInstanceTemporaryCapacityRequest::setAcceptLanguage(const std::string &acceptLanguage) { + acceptLanguage_ = acceptLanguage; + setBodyParameter(std::string("AcceptLanguage"), acceptLanguage); +} + diff --git a/oceanbasepro/src/model/ModifyTenantPrimaryZoneRequest.cc b/oceanbasepro/src/model/ModifyTenantPrimaryZoneRequest.cc index 8ee9860ea..ce11bb8fc 100644 --- a/oceanbasepro/src/model/ModifyTenantPrimaryZoneRequest.cc +++ b/oceanbasepro/src/model/ModifyTenantPrimaryZoneRequest.cc @@ -25,6 +25,15 @@ ModifyTenantPrimaryZoneRequest::ModifyTenantPrimaryZoneRequest() ModifyTenantPrimaryZoneRequest::~ModifyTenantPrimaryZoneRequest() {} +std::string ModifyTenantPrimaryZoneRequest::getTenantEndpointDirectId() const { + return tenantEndpointDirectId_; +} + +void ModifyTenantPrimaryZoneRequest::setTenantEndpointDirectId(const std::string &tenantEndpointDirectId) { + tenantEndpointDirectId_ = tenantEndpointDirectId; + setBodyParameter(std::string("TenantEndpointDirectId"), tenantEndpointDirectId); +} + std::string ModifyTenantPrimaryZoneRequest::getUserVSwitchId() const { return userVSwitchId_; } @@ -79,3 +88,12 @@ void ModifyTenantPrimaryZoneRequest::setPrimaryZone(const std::string &primaryZo setBodyParameter(std::string("PrimaryZone"), primaryZone); } +std::string ModifyTenantPrimaryZoneRequest::getUserDirectVSwitchId() const { + return userDirectVSwitchId_; +} + +void ModifyTenantPrimaryZoneRequest::setUserDirectVSwitchId(const std::string &userDirectVSwitchId) { + userDirectVSwitchId_ = userDirectVSwitchId; + setBodyParameter(std::string("UserDirectVSwitchId"), userDirectVSwitchId); +} +