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

Generated 2019-09-01 for OceanBasePro.

Browse Source
This commit is contained in:
sdk-team
2023-12-28 11:31:26 +00:00
parent e9cb30aad0
commit 0d265770f7
21 changed files with 334 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h
View File

@@ -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_;
};

8
oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h
View File

@@ -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<Data::RolesItem> roles;
std::vector<RolesItem> roles;
std::string userType;
std::string userStatus;
};
@@ -49,12 +49,12 @@ namespace AlibabaCloud
CreateTenantUserResult();
explicit CreateTenantUserResult(const std::string &payload);
~CreateTenantUserResult();
std::vector<Data> getTenantUser()const;
TenantUser getTenantUser()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Data> tenantUser_;
TenantUser tenantUser_;
};
}

1
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h
View File

@@ -50,6 +50,7 @@ namespace AlibabaCloud
};
std::vector<std::string> nodeNum;
DiskSizeRange diskSizeRange;
std::vector<std::string> diskTypes;
std::string instanceClass;
std::string spec;
LogDiskSizeRange logDiskSizeRange;

50
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h
View File

@@ -65,6 +65,7 @@ namespace AlibabaCloud
{
std::string maxLogAssignedPercent;
std::string logAssignedSize;
int originalTotalDiskSize;
std::vector<std::string> 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<std::string> maxDiskUsedObServer6;
};
struct LogDiskSize4
{
std::string maxLogAssignedPercent;
std::string logAssignedSize;
long unitDiskSize;
long totalDiskSize;
std::vector<std::string> 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;

4
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h
View File

@@ -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<NodesItem::NodeResourceItem> nodeResource;
std::string replicaType;
std::string nodeId;
long readOnlyCopyId;
std::string nodeStatus;
long fullCopyId;
long nodeCopyId;
};
std::string zoneId;

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeMetricsDataRequest.h
View File

@@ -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_;

49
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h
View File

@@ -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<std::string> 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<TenantZonesItem::TenantZoneReplicasItem> 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<std::string> availableZones;
std::string diskType;

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h
View File

@@ -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_;
};

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h
View File

@@ -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

6
oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantPrimaryZoneRequest.h
View File

@@ -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

18
oceanbasepro/src/model/CreateInstanceRequest.cc
View File

@@ -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_;
}

37
oceanbasepro/src/model/CreateTenantUserResult.cc
View File

@@ -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::Data> CreateTenantUserResult::getTenantUser()const
CreateTenantUserResult::TenantUser CreateTenantUserResult::getTenantUser()const
{
return tenantUser_;
}

3
oceanbasepro/src/model/DescribeAvailableSpecResult.cc
View File

@@ -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);
}

60
oceanbasepro/src/model/DescribeInstanceResult.cc
View File

@@ -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());

8
oceanbasepro/src/model/DescribeInstanceTopologyResult.cc
View File

@@ -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)
{

9
oceanbasepro/src/model/DescribeMetricsDataRequest.cc
View File

@@ -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_;
}

54
oceanbasepro/src/model/DescribeTenantResult.cc
View File

@@ -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());

9
oceanbasepro/src/model/ModifyInstanceSpecRequest.cc
View File

@@ -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_;
}

9
oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc
View File

@@ -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);
}

18
oceanbasepro/src/model/ModifyTenantPrimaryZoneRequest.cc
View File

@@ -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);
}