Generated 2015-12-01 for Dds.

dds/src/DdsClient.cc

@@ -3723,36 +3723,36 @@ DdsClient::RestartDBInstanceOutcomeCallable DdsClient::restartDBInstanceCallable
 	return task->get_future();
 }
 
-DdsClient::RestoreDBInstanceOutcome DdsClient::restoreDBInstance(const RestoreDBInstanceRequest &request) const
+DdsClient::RestartNodeOutcome DdsClient::restartNode(const RestartNodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return RestoreDBInstanceOutcome(endpointOutcome.error());
+		return RestartNodeOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return RestoreDBInstanceOutcome(RestoreDBInstanceResult(outcome.result()));
+		return RestartNodeOutcome(RestartNodeResult(outcome.result()));
 	else
-		return RestoreDBInstanceOutcome(outcome.error());
+		return RestartNodeOutcome(outcome.error());
 }
 
-void DdsClient::restoreDBInstanceAsync(const RestoreDBInstanceRequest& request, const RestoreDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void DdsClient::restartNodeAsync(const RestartNodeRequest& request, const RestartNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, restoreDBInstance(request), context);
+		handler(this, request, restartNode(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-DdsClient::RestoreDBInstanceOutcomeCallable DdsClient::restoreDBInstanceCallable(const RestoreDBInstanceRequest &request) const
+DdsClient::RestartNodeOutcomeCallable DdsClient::restartNodeCallable(const RestartNodeRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<RestoreDBInstanceOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<RestartNodeOutcome()>>(
 			[this, request]()
 			{
-			return this->restoreDBInstance(request);
+			return this->restartNode(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

dds/src/model/MigrateAvailableZoneRequest.cc

@@ -34,6 +34,15 @@ void MigrateAvailableZoneRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+std::string MigrateAvailableZoneRequest::getSecondaryZoneId() const {
+  return secondaryZoneId_;
+}
+
+void MigrateAvailableZoneRequest::setSecondaryZoneId(const std::string &secondaryZoneId) {
+  secondaryZoneId_ = secondaryZoneId;
+  setParameter(std::string("SecondaryZoneId"), secondaryZoneId);
+}
+
 std::string MigrateAvailableZoneRequest::getAccessKeyId() const {
   return accessKeyId_;
 }
@@ -52,6 +61,15 @@ void MigrateAvailableZoneRequest::setEffectiveTime(const std::string &effectiveT
   setParameter(std::string("EffectiveTime"), effectiveTime);
 }
 
+std::string MigrateAvailableZoneRequest::getHiddenZoneId() const {
+  return hiddenZoneId_;
+}
+
+void MigrateAvailableZoneRequest::setHiddenZoneId(const std::string &hiddenZoneId) {
+  hiddenZoneId_ = hiddenZoneId;
+  setParameter(std::string("HiddenZoneId"), hiddenZoneId);
+}
+
 std::string MigrateAvailableZoneRequest::getDBInstanceId() const {
   return dBInstanceId_;
 }

dds/src/model/RestartNodeRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * 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/dds/model/RestartNodeRequest.h>
+
+using AlibabaCloud::Dds::Model::RestartNodeRequest;
+
+RestartNodeRequest::RestartNodeRequest()
+    : RpcServiceRequest("dds", "2015-12-01", "RestartNode") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RestartNodeRequest::~RestartNodeRequest() {}
+
+long RestartNodeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void RestartNodeRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string RestartNodeRequest::getRoleId() const {
+  return roleId_;
+}
+
+void RestartNodeRequest::setRoleId(const std::string &roleId) {
+  roleId_ = roleId;
+  setParameter(std::string("RoleId"), roleId);
+}
+
+std::string RestartNodeRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void RestartNodeRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string RestartNodeRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void RestartNodeRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+
+std::string RestartNodeRequest::getNodeId() const {
+  return nodeId_;
+}
+
+void RestartNodeRequest::setNodeId(const std::string &nodeId) {
+  nodeId_ = nodeId;
+  setParameter(std::string("NodeId"), nodeId);
+}
+
+std::string RestartNodeRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void RestartNodeRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string RestartNodeRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void RestartNodeRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long RestartNodeRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void RestartNodeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

dds/src/model/RestartNodeResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/dds/model/RestoreDBInstanceResult.h>
+#include <alibabacloud/dds/model/RestartNodeResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Dds;
 using namespace AlibabaCloud::Dds::Model;
 
-RestoreDBInstanceResult::RestoreDBInstanceResult() :
+RestartNodeResult::RestartNodeResult() :
 	ServiceResult()
 {}
 
-RestoreDBInstanceResult::RestoreDBInstanceResult(const std::string &payload) :
+RestartNodeResult::RestartNodeResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-RestoreDBInstanceResult::~RestoreDBInstanceResult()
+RestartNodeResult::~RestartNodeResult()
 {}
 
-void RestoreDBInstanceResult::parse(const std::string &payload)
+void RestartNodeResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

dds/src/model/RestoreDBInstanceRequest.cc

@@ -1,90 +0,0 @@
-/*
- * 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/dds/model/RestoreDBInstanceRequest.h>
-
-using AlibabaCloud::Dds::Model::RestoreDBInstanceRequest;
-
-RestoreDBInstanceRequest::RestoreDBInstanceRequest()
-    : RpcServiceRequest("dds", "2015-12-01", "RestoreDBInstance") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-RestoreDBInstanceRequest::~RestoreDBInstanceRequest() {}
-
-long RestoreDBInstanceRequest::getResourceOwnerId() const {
-  return resourceOwnerId_;
-}
-
-void RestoreDBInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
-  resourceOwnerId_ = resourceOwnerId;
-  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
-}
-
-std::string RestoreDBInstanceRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void RestoreDBInstanceRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string RestoreDBInstanceRequest::getDBInstanceId() const {
-  return dBInstanceId_;
-}
-
-void RestoreDBInstanceRequest::setDBInstanceId(const std::string &dBInstanceId) {
-  dBInstanceId_ = dBInstanceId;
-  setParameter(std::string("DBInstanceId"), dBInstanceId);
-}
-
-std::string RestoreDBInstanceRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void RestoreDBInstanceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-std::string RestoreDBInstanceRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void RestoreDBInstanceRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
-}
-
-int RestoreDBInstanceRequest::getBackupId() const {
-  return backupId_;
-}
-
-void RestoreDBInstanceRequest::setBackupId(int backupId) {
-  backupId_ = backupId;
-  setParameter(std::string("BackupId"), std::to_string(backupId));
-}
-
-long RestoreDBInstanceRequest::getOwnerId() const {
-  return ownerId_;
-}
-
-void RestoreDBInstanceRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
-}
-