Lindorm open api.

hitsdb/src/HitsdbClient.cc

@@ -51,6 +51,42 @@ HitsdbClient::HitsdbClient(const std::string & accessKeyId, const std::string &
 HitsdbClient::~HitsdbClient()
 {}
 
+HitsdbClient::CreateLdpsNamespaceOutcome HitsdbClient::createLdpsNamespace(const CreateLdpsNamespaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateLdpsNamespaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateLdpsNamespaceOutcome(CreateLdpsNamespaceResult(outcome.result()));
+	else
+		return CreateLdpsNamespaceOutcome(outcome.error());
+}
+
+void HitsdbClient::createLdpsNamespaceAsync(const CreateLdpsNamespaceRequest& request, const CreateLdpsNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createLdpsNamespace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HitsdbClient::CreateLdpsNamespaceOutcomeCallable HitsdbClient::createLdpsNamespaceCallable(const CreateLdpsNamespaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateLdpsNamespaceOutcome()>>(
+			[this, request]()
+			{
+			return this->createLdpsNamespace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HitsdbClient::CreateLindormInstanceOutcome HitsdbClient::createLindormInstance(const CreateLindormInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,78 @@ HitsdbClient::GetInstanceIpWhiteListOutcomeCallable HitsdbClient::getInstanceIpW
 	return task->get_future();
 }
 
+HitsdbClient::GetLdpsNamespacedQuotaOutcome HitsdbClient::getLdpsNamespacedQuota(const GetLdpsNamespacedQuotaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetLdpsNamespacedQuotaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetLdpsNamespacedQuotaOutcome(GetLdpsNamespacedQuotaResult(outcome.result()));
+	else
+		return GetLdpsNamespacedQuotaOutcome(outcome.error());
+}
+
+void HitsdbClient::getLdpsNamespacedQuotaAsync(const GetLdpsNamespacedQuotaRequest& request, const GetLdpsNamespacedQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getLdpsNamespacedQuota(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HitsdbClient::GetLdpsNamespacedQuotaOutcomeCallable HitsdbClient::getLdpsNamespacedQuotaCallable(const GetLdpsNamespacedQuotaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetLdpsNamespacedQuotaOutcome()>>(
+			[this, request]()
+			{
+			return this->getLdpsNamespacedQuota(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HitsdbClient::GetLdpsResourceCostOutcome HitsdbClient::getLdpsResourceCost(const GetLdpsResourceCostRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetLdpsResourceCostOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetLdpsResourceCostOutcome(GetLdpsResourceCostResult(outcome.result()));
+	else
+		return GetLdpsResourceCostOutcome(outcome.error());
+}
+
+void HitsdbClient::getLdpsResourceCostAsync(const GetLdpsResourceCostRequest& request, const GetLdpsResourceCostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getLdpsResourceCost(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HitsdbClient::GetLdpsResourceCostOutcomeCallable HitsdbClient::getLdpsResourceCostCallable(const GetLdpsResourceCostRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetLdpsResourceCostOutcome()>>(
+			[this, request]()
+			{
+			return this->getLdpsResourceCost(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HitsdbClient::GetLindormInstanceOutcome HitsdbClient::getLindormInstance(const GetLindormInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

hitsdb/src/model/CreateLdpsNamespaceRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h>
+
+using AlibabaCloud::Hitsdb::Model::CreateLdpsNamespaceRequest;
+
+CreateLdpsNamespaceRequest::CreateLdpsNamespaceRequest()
+    : RpcServiceRequest("hitsdb", "2020-06-15", "CreateLdpsNamespace") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateLdpsNamespaceRequest::~CreateLdpsNamespaceRequest() {}
+
+long CreateLdpsNamespaceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateLdpsNamespaceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateLdpsNamespaceRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateLdpsNamespaceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateLdpsNamespaceRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void CreateLdpsNamespaceRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
+std::string CreateLdpsNamespaceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateLdpsNamespaceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateLdpsNamespaceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateLdpsNamespaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateLdpsNamespaceRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateLdpsNamespaceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateLdpsNamespaceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateLdpsNamespaceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateLdpsNamespaceRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void CreateLdpsNamespaceRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string CreateLdpsNamespaceRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void CreateLdpsNamespaceRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+

hitsdb/src/model/CreateLdpsNamespaceResult.cc

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

hitsdb/src/model/CreateLindormInstanceRequest.cc

@@ -133,6 +133,15 @@ void CreateLindormInstanceRequest::setVSwitchId(const std::string &vSwitchId) {
   setParameter(std::string("VSwitchId"), vSwitchId);
 }
 
+int CreateLindormInstanceRequest::getStreamNum() const {
+  return streamNum_;
+}
+
+void CreateLindormInstanceRequest::setStreamNum(int streamNum) {
+  streamNum_ = streamNum;
+  setParameter(std::string("StreamNum"), std::to_string(streamNum));
+}
+
 int CreateLindormInstanceRequest::getLogSingleStorage() const {
   return logSingleStorage_;
 }
@@ -358,6 +367,15 @@ void CreateLindormInstanceRequest::setFilestoreNum(int filestoreNum) {
   setParameter(std::string("FilestoreNum"), std::to_string(filestoreNum));
 }
 
+std::string CreateLindormInstanceRequest::getStreamSpec() const {
+  return streamSpec_;
+}
+
+void CreateLindormInstanceRequest::setStreamSpec(const std::string &streamSpec) {
+  streamSpec_ = streamSpec;
+  setParameter(std::string("StreamSpec"), streamSpec);
+}
+
 std::string CreateLindormInstanceRequest::getCoreSpec() const {
   return coreSpec_;
 }

hitsdb/src/model/GetInstanceIpWhiteListResult.cc

@@ -39,6 +39,16 @@ void GetInstanceIpWhiteListResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allGroupListNode = value["GroupList"]["GroupListItem"];
+	for (auto valueGroupListGroupListItem : allGroupListNode)
+	{
+		GroupListItem groupListObject;
+		if(!valueGroupListGroupListItem["GroupName"].isNull())
+			groupListObject.groupName = valueGroupListGroupListItem["GroupName"].asString();
+		if(!valueGroupListGroupListItem["SecurityIpList"].isNull())
+			groupListObject.securityIpList = valueGroupListGroupListItem["SecurityIpList"].asString();
+		groupList_.push_back(groupListObject);
+	}
 	auto allIpList = value["IpList"]["IpList"];
 	for (const auto &item : allIpList)
 		ipList_.push_back(item.asString());
@@ -47,6 +57,11 @@ void GetInstanceIpWhiteListResult::parse(const std::string &payload)
 
 }
 
+std::vector<GetInstanceIpWhiteListResult::GroupListItem> GetInstanceIpWhiteListResult::getGroupList()const
+{
+	return groupList_;
+}
+
 std::vector<std::string> GetInstanceIpWhiteListResult::getIpList()const
 {
 	return ipList_;

hitsdb/src/model/GetLdpsNamespacedQuotaRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h>
+
+using AlibabaCloud::Hitsdb::Model::GetLdpsNamespacedQuotaRequest;
+
+GetLdpsNamespacedQuotaRequest::GetLdpsNamespacedQuotaRequest()
+    : RpcServiceRequest("hitsdb", "2020-06-15", "GetLdpsNamespacedQuota") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetLdpsNamespacedQuotaRequest::~GetLdpsNamespacedQuotaRequest() {}
+
+long GetLdpsNamespacedQuotaRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long GetLdpsNamespacedQuotaRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void GetLdpsNamespacedQuotaRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+

hitsdb/src/model/GetLdpsNamespacedQuotaResult.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Hitsdb;
+using namespace AlibabaCloud::Hitsdb::Model;
+
+GetLdpsNamespacedQuotaResult::GetLdpsNamespacedQuotaResult() :
+	ServiceResult()
+{}
+
+GetLdpsNamespacedQuotaResult::GetLdpsNamespacedQuotaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetLdpsNamespacedQuotaResult::~GetLdpsNamespacedQuotaResult()
+{}
+
+void GetLdpsNamespacedQuotaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allNamespacedQuotasNode = value["NamespacedQuotas"]["NamespacedQuota"];
+	for (auto valueNamespacedQuotasNamespacedQuota : allNamespacedQuotasNode)
+	{
+		NamespacedQuota namespacedQuotasObject;
+		if(!valueNamespacedQuotasNamespacedQuota["Name"].isNull())
+			namespacedQuotasObject.name = valueNamespacedQuotasNamespacedQuota["Name"].asString();
+		if(!valueNamespacedQuotasNamespacedQuota["CpuAmount"].isNull())
+			namespacedQuotasObject.cpuAmount = valueNamespacedQuotasNamespacedQuota["CpuAmount"].asString();
+		if(!valueNamespacedQuotasNamespacedQuota["MemoryAmount"].isNull())
+			namespacedQuotasObject.memoryAmount = valueNamespacedQuotasNamespacedQuota["MemoryAmount"].asString();
+		if(!valueNamespacedQuotasNamespacedQuota["UsedCpu"].isNull())
+			namespacedQuotasObject.usedCpu = valueNamespacedQuotasNamespacedQuota["UsedCpu"].asString();
+		if(!valueNamespacedQuotasNamespacedQuota["UsedMemory"].isNull())
+			namespacedQuotasObject.usedMemory = valueNamespacedQuotasNamespacedQuota["UsedMemory"].asString();
+		namespacedQuotas_.push_back(namespacedQuotasObject);
+	}
+
+}
+
+std::vector<GetLdpsNamespacedQuotaResult::NamespacedQuota> GetLdpsNamespacedQuotaResult::getNamespacedQuotas()const
+{
+	return namespacedQuotas_;
+}
+

hitsdb/src/model/GetLdpsResourceCostRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h>
+
+using AlibabaCloud::Hitsdb::Model::GetLdpsResourceCostRequest;
+
+GetLdpsResourceCostRequest::GetLdpsResourceCostRequest()
+    : RpcServiceRequest("hitsdb", "2020-06-15", "GetLdpsResourceCost") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetLdpsResourceCostRequest::~GetLdpsResourceCostRequest() {}
+
+long GetLdpsResourceCostRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void GetLdpsResourceCostRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+long GetLdpsResourceCostRequest::getStartTime() const {
+  return startTime_;
+}
+
+void GetLdpsResourceCostRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
+}
+
+std::string GetLdpsResourceCostRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetLdpsResourceCostRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetLdpsResourceCostRequest::getJobId() const {
+  return jobId_;
+}
+
+void GetLdpsResourceCostRequest::setJobId(const std::string &jobId) {
+  jobId_ = jobId;
+  setParameter(std::string("JobId"), jobId);
+}
+
+std::string GetLdpsResourceCostRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void GetLdpsResourceCostRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
+std::string GetLdpsResourceCostRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetLdpsResourceCostRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetLdpsResourceCostRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetLdpsResourceCostRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetLdpsResourceCostRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetLdpsResourceCostRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long GetLdpsResourceCostRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetLdpsResourceCostRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetLdpsResourceCostRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetLdpsResourceCostRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string GetLdpsResourceCostRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void GetLdpsResourceCostRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+

hitsdb/src/model/GetLdpsResourceCostResult.cc

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

hitsdb/src/model/GetLindormInstanceResult.cc

@@ -73,6 +73,8 @@ void GetLindormInstanceResult::parse(const std::string &payload)
 		serviceType_ = value["ServiceType"].asString();
 	if(!value["EnableKms"].isNull())
 		enableKms_ = value["EnableKms"].asString() == "true";
+	if(!value["EnableML"].isNull())
+		enableML_ = value["EnableML"].asString() == "true";
 	if(!value["DiskUsage"].isNull())
 		diskUsage_ = value["DiskUsage"].asString();
 	if(!value["DiskCategory"].isNull())
@@ -117,12 +119,18 @@ void GetLindormInstanceResult::parse(const std::string &payload)
 		enableCompute_ = value["EnableCompute"].asString() == "true";
 	if(!value["EnableSSL"].isNull())
 		enableSSL_ = value["EnableSSL"].asString() == "true";
+	if(!value["EnableMLCtrl"].isNull())
+		enableMLCtrl_ = value["EnableMLCtrl"].asString() == "true";
 	if(!value["EnableCdc"].isNull())
 		enableCdc_ = value["EnableCdc"].asString() == "true";
 	if(!value["EnableStream"].isNull())
 		enableStream_ = value["EnableStream"].asString() == "true";
+	if(!value["EnableLTS"].isNull())
+		enableLTS_ = value["EnableLTS"].asString() == "true";
 	if(!value["EnableShs"].isNull())
 		enableShs_ = value["EnableShs"].asString() == "true";
+	if(!value["EnableBlob"].isNull())
+		enableBlob_ = value["EnableBlob"].asString() == "true";
 	if(!value["MaintainStartTime"].isNull())
 		maintainStartTime_ = value["MaintainStartTime"].asString();
 	if(!value["MaintainEndTime"].isNull())
@@ -163,6 +171,10 @@ void GetLindormInstanceResult::parse(const std::string &payload)
 		logNum_ = std::stoi(value["LogNum"].asString());
 	if(!value["LogSingleStorage"].isNull())
 		logSingleStorage_ = std::stoi(value["LogSingleStorage"].asString());
+	if(!value["ArchVersion"].isNull())
+		archVersion_ = value["ArchVersion"].asString();
+	if(!value["EnableLsqlVersionV3"].isNull())
+		enableLsqlVersionV3_ = value["EnableLsqlVersionV3"].asString() == "true";
 
 }
 
@@ -181,6 +193,11 @@ std::vector<GetLindormInstanceResult::Engine> GetLindormInstanceResult::getEngin
 	return engineList_;
 }
 
+bool GetLindormInstanceResult::getEnableLTS()const
+{
+	return enableLTS_;
+}
+
 std::string GetLindormInstanceResult::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -301,6 +318,11 @@ bool GetLindormInstanceResult::getEnableCdc()const
 	return enableCdc_;
 }
 
+bool GetLindormInstanceResult::getEnableMLCtrl()const
+{
+	return enableMLCtrl_;
+}
+
 bool GetLindormInstanceResult::getEnableStream()const
 {
 	return enableStream_;
@@ -321,6 +343,11 @@ std::string GetLindormInstanceResult::getExpireTime()const
 	return expireTime_;
 }
 
+bool GetLindormInstanceResult::getEnableML()const
+{
+	return enableML_;
+}
+
 int GetLindormInstanceResult::getLogNum()const
 {
 	return logNum_;
@@ -331,11 +358,21 @@ int GetLindormInstanceResult::getLocalCloudStorage()const
 	return localCloudStorage_;
 }
 
+bool GetLindormInstanceResult::getEnableBlob()const
+{
+	return enableBlob_;
+}
+
 std::string GetLindormInstanceResult::getDiskThreshold()const
 {
 	return diskThreshold_;
 }
 
+bool GetLindormInstanceResult::getEnableLsqlVersionV3()const
+{
+	return enableLsqlVersionV3_;
+}
+
 bool GetLindormInstanceResult::getAutoRenew()const
 {
 	return autoRenew_;
@@ -401,6 +438,11 @@ int GetLindormInstanceResult::getCoreNum()const
 	return coreNum_;
 }
 
+std::string GetLindormInstanceResult::getArchVersion()const
+{
+	return archVersion_;
+}
+
 std::string GetLindormInstanceResult::getCreateTime()const
 {
 	return createTime_;

hitsdb/src/model/ReleaseLindormInstanceRequest.cc

@@ -34,6 +34,15 @@ void ReleaseLindormInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+bool ReleaseLindormInstanceRequest::getImmediately() const {
+  return immediately_;
+}
+
+void ReleaseLindormInstanceRequest::setImmediately(bool immediately) {
+  immediately_ = immediately;
+  setParameter(std::string("Immediately"), immediately ? "true" : "false");
+}
+
 std::string ReleaseLindormInstanceRequest::getAccessKeyId() const {
   return accessKeyId_;
 }

hitsdb/src/model/UpdateInstanceIpWhiteListRequest.cc

@@ -34,6 +34,15 @@ void UpdateInstanceIpWhiteListRequest::setResourceOwnerId(long resourceOwnerId)
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+bool UpdateInstanceIpWhiteListRequest::get_Delete() const {
+  return _delete_;
+}
+
+void UpdateInstanceIpWhiteListRequest::set_Delete(bool _delete) {
+  _delete_ = _delete;
+  setParameter(std::string("Delete"), _delete ? "true" : "false");
+}
+
 std::string UpdateInstanceIpWhiteListRequest::getAccessKeyId() const {
   return accessKeyId_;
 }

hitsdb/src/model/UpgradeLindormInstanceRequest.cc

@@ -34,22 +34,112 @@ void UpgradeLindormInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-int UpgradeLindormInstanceRequest::getPhoenixCoreNum() const {
-  return phoenixCoreNum_;
+std::string UpgradeLindormInstanceRequest::getLogSpec() const {
+  return logSpec_;
 }
 
-void UpgradeLindormInstanceRequest::setPhoenixCoreNum(int phoenixCoreNum) {
-  phoenixCoreNum_ = phoenixCoreNum;
-  setParameter(std::string("PhoenixCoreNum"), std::to_string(phoenixCoreNum));
+void UpgradeLindormInstanceRequest::setLogSpec(const std::string &logSpec) {
+  logSpec_ = logSpec;
+  setParameter(std::string("LogSpec"), logSpec);
 }
 
-std::string UpgradeLindormInstanceRequest::getPhoenixCoreSpec() const {
-  return phoenixCoreSpec_;
+std::string UpgradeLindormInstanceRequest::getSecurityToken() const {
+  return securityToken_;
 }
 
-void UpgradeLindormInstanceRequest::setPhoenixCoreSpec(const std::string &phoenixCoreSpec) {
-  phoenixCoreSpec_ = phoenixCoreSpec;
-  setParameter(std::string("PhoenixCoreSpec"), phoenixCoreSpec);
+void UpgradeLindormInstanceRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
+int UpgradeLindormInstanceRequest::getTsdbNum() const {
+  return tsdbNum_;
+}
+
+void UpgradeLindormInstanceRequest::setTsdbNum(int tsdbNum) {
+  tsdbNum_ = tsdbNum;
+  setParameter(std::string("TsdbNum"), std::to_string(tsdbNum));
+}
+
+int UpgradeLindormInstanceRequest::getSolrNum() const {
+  return solrNum_;
+}
+
+void UpgradeLindormInstanceRequest::setSolrNum(int solrNum) {
+  solrNum_ = solrNum;
+  setParameter(std::string("SolrNum"), std::to_string(solrNum));
+}
+
+long UpgradeLindormInstanceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void UpgradeLindormInstanceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+int UpgradeLindormInstanceRequest::getLindormNum() const {
+  return lindormNum_;
+}
+
+void UpgradeLindormInstanceRequest::setLindormNum(int lindormNum) {
+  lindormNum_ = lindormNum;
+  setParameter(std::string("LindormNum"), std::to_string(lindormNum));
+}
+
+int UpgradeLindormInstanceRequest::getLtsCoreNum() const {
+  return ltsCoreNum_;
+}
+
+void UpgradeLindormInstanceRequest::setLtsCoreNum(int ltsCoreNum) {
+  ltsCoreNum_ = ltsCoreNum;
+  setParameter(std::string("LtsCoreNum"), std::to_string(ltsCoreNum));
+}
+
+std::string UpgradeLindormInstanceRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void UpgradeLindormInstanceRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+int UpgradeLindormInstanceRequest::getMlNum() const {
+  return mlNum_;
+}
+
+void UpgradeLindormInstanceRequest::setMlNum(int mlNum) {
+  mlNum_ = mlNum;
+  setParameter(std::string("MlNum"), std::to_string(mlNum));
+}
+
+int UpgradeLindormInstanceRequest::getStreamNum() const {
+  return streamNum_;
+}
+
+void UpgradeLindormInstanceRequest::setStreamNum(int streamNum) {
+  streamNum_ = streamNum;
+  setParameter(std::string("StreamNum"), std::to_string(streamNum));
+}
+
+int UpgradeLindormInstanceRequest::getLogSingleStorage() const {
+  return logSingleStorage_;
+}
+
+void UpgradeLindormInstanceRequest::setLogSingleStorage(int logSingleStorage) {
+  logSingleStorage_ = logSingleStorage;
+  setParameter(std::string("LogSingleStorage"), std::to_string(logSingleStorage));
+}
+
+std::string UpgradeLindormInstanceRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void UpgradeLindormInstanceRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
 }
 
 std::string UpgradeLindormInstanceRequest::getClientToken() const {
@@ -97,24 +187,6 @@ void UpgradeLindormInstanceRequest::setAccessKeyId(const std::string &accessKeyI
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-std::string UpgradeLindormInstanceRequest::getLogSpec() const {
-  return logSpec_;
-}
-
-void UpgradeLindormInstanceRequest::setLogSpec(const std::string &logSpec) {
-  logSpec_ = logSpec;
-  setParameter(std::string("LogSpec"), logSpec);
-}
-
-std::string UpgradeLindormInstanceRequest::getSecurityToken() const {
-  return securityToken_;
-}
-
-void UpgradeLindormInstanceRequest::setSecurityToken(const std::string &securityToken) {
-  securityToken_ = securityToken;
-  setParameter(std::string("SecurityToken"), securityToken);
-}
-
 std::string UpgradeLindormInstanceRequest::getRegionId() const {
   return regionId_;
 }
@@ -124,15 +196,6 @@ void UpgradeLindormInstanceRequest::setRegionId(const std::string &regionId) {
   setParameter(std::string("RegionId"), regionId);
 }
 
-int UpgradeLindormInstanceRequest::getTsdbNum() const {
-  return tsdbNum_;
-}
-
-void UpgradeLindormInstanceRequest::setTsdbNum(int tsdbNum) {
-  tsdbNum_ = tsdbNum;
-  setParameter(std::string("TsdbNum"), std::to_string(tsdbNum));
-}
-
 std::string UpgradeLindormInstanceRequest::getLindormSpec() const {
   return lindormSpec_;
 }
@@ -142,15 +205,6 @@ void UpgradeLindormInstanceRequest::setLindormSpec(const std::string &lindormSpe
   setParameter(std::string("LindormSpec"), lindormSpec);
 }
 
-int UpgradeLindormInstanceRequest::getSolrNum() const {
-  return solrNum_;
-}
-
-void UpgradeLindormInstanceRequest::setSolrNum(int solrNum) {
-  solrNum_ = solrNum;
-  setParameter(std::string("SolrNum"), std::to_string(solrNum));
-}
-
 int UpgradeLindormInstanceRequest::getColdStorage() const {
   return coldStorage_;
 }
@@ -214,40 +268,22 @@ void UpgradeLindormInstanceRequest::setFilestoreNum(int filestoreNum) {
   setParameter(std::string("FilestoreNum"), std::to_string(filestoreNum));
 }
 
-long UpgradeLindormInstanceRequest::getOwnerId() const {
-  return ownerId_;
+std::string UpgradeLindormInstanceRequest::getStreamSpec() const {
+  return streamSpec_;
 }
 
-void UpgradeLindormInstanceRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+void UpgradeLindormInstanceRequest::setStreamSpec(const std::string &streamSpec) {
+  streamSpec_ = streamSpec;
+  setParameter(std::string("StreamSpec"), streamSpec);
 }
 
-int UpgradeLindormInstanceRequest::getLindormNum() const {
-  return lindormNum_;
+std::string UpgradeLindormInstanceRequest::getMlSpec() const {
+  return mlSpec_;
 }
 
-void UpgradeLindormInstanceRequest::setLindormNum(int lindormNum) {
-  lindormNum_ = lindormNum;
-  setParameter(std::string("LindormNum"), std::to_string(lindormNum));
-}
-
-int UpgradeLindormInstanceRequest::getLtsCoreNum() const {
-  return ltsCoreNum_;
-}
-
-void UpgradeLindormInstanceRequest::setLtsCoreNum(int ltsCoreNum) {
-  ltsCoreNum_ = ltsCoreNum;
-  setParameter(std::string("LtsCoreNum"), std::to_string(ltsCoreNum));
-}
-
-std::string UpgradeLindormInstanceRequest::getInstanceId() const {
-  return instanceId_;
-}
-
-void UpgradeLindormInstanceRequest::setInstanceId(const std::string &instanceId) {
-  instanceId_ = instanceId;
-  setParameter(std::string("InstanceId"), instanceId);
+void UpgradeLindormInstanceRequest::setMlSpec(const std::string &mlSpec) {
+  mlSpec_ = mlSpec;
+  setParameter(std::string("MlSpec"), mlSpec);
 }
 
 std::string UpgradeLindormInstanceRequest::getLtsCoreSpec() const {
@@ -268,21 +304,3 @@ void UpgradeLindormInstanceRequest::setClusterStorage(int clusterStorage) {
   setParameter(std::string("ClusterStorage"), std::to_string(clusterStorage));
 }
 
-int UpgradeLindormInstanceRequest::getLogSingleStorage() const {
-  return logSingleStorage_;
-}
-
-void UpgradeLindormInstanceRequest::setLogSingleStorage(int logSingleStorage) {
-  logSingleStorage_ = logSingleStorage;
-  setParameter(std::string("LogSingleStorage"), std::to_string(logSingleStorage));
-}
-
-std::string UpgradeLindormInstanceRequest::getZoneId() const {
-  return zoneId_;
-}
-
-void UpgradeLindormInstanceRequest::setZoneId(const std::string &zoneId) {
-  zoneId_ = zoneId;
-  setParameter(std::string("ZoneId"), zoneId);
-}
-