Added Global Distribute Cache OpenAPIs.

CHANGELOG

@@ -1,3 +1,7 @@
+2020-08-20 Version: 1.36.601
+- Added Global Distribute Cache OpenAPIs.
+- Added direct connection OpenAPIs.
+
 2020-08-19 Version: 1.36.600
 - Add DescribeLiveDomainCertificateInfo.
 

VERSION

@@ -1 +1 @@
-1.36.600
+1.36.601

r-kvstore/CMakeLists.txt

@@ -21,6 +21,8 @@ set(r-kvstore_public_header
 	include/alibabacloud/r-kvstore/R_kvstoreExport.h )
 
 set(r-kvstore_public_header_model 
+	include/alibabacloud/r-kvstore/model/AllocateDirectConnectionRequest.h
+	include/alibabacloud/r-kvstore/model/AllocateDirectConnectionResult.h
 	include/alibabacloud/r-kvstore/model/AllocateInstancePublicConnectionRequest.h
 	include/alibabacloud/r-kvstore/model/AllocateInstancePublicConnectionResult.h
 	include/alibabacloud/r-kvstore/model/CreateAccountRequest.h
@@ -33,6 +35,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/CreateDedicatedInstanceResult.h
 	include/alibabacloud/r-kvstore/model/CreateDedicatedUserClusterRequest.h
 	include/alibabacloud/r-kvstore/model/CreateDedicatedUserClusterResult.h
+	include/alibabacloud/r-kvstore/model/CreateGlobalDistributeCacheRequest.h
+	include/alibabacloud/r-kvstore/model/CreateGlobalDistributeCacheResult.h
 	include/alibabacloud/r-kvstore/model/CreateInstanceRequest.h
 	include/alibabacloud/r-kvstore/model/CreateInstanceResult.h
 	include/alibabacloud/r-kvstore/model/CreateUserClusterHostRequest.h
@@ -67,6 +71,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/DescribeDedicatedClusterInstanceListResult.h
 	include/alibabacloud/r-kvstore/model/DescribeDedicatedUserClusterRequest.h
 	include/alibabacloud/r-kvstore/model/DescribeDedicatedUserClusterResult.h
+	include/alibabacloud/r-kvstore/model/DescribeGlobalDistributeCacheRequest.h
+	include/alibabacloud/r-kvstore/model/DescribeGlobalDistributeCacheResult.h
 	include/alibabacloud/r-kvstore/model/DescribeHistoryMonitorValuesRequest.h
 	include/alibabacloud/r-kvstore/model/DescribeHistoryMonitorValuesResult.h
 	include/alibabacloud/r-kvstore/model/DescribeInstanceAttributeRequest.h
@@ -155,6 +161,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/ModifySecurityIpsResult.h
 	include/alibabacloud/r-kvstore/model/ModifyUserClusterHostRequest.h
 	include/alibabacloud/r-kvstore/model/ModifyUserClusterHostResult.h
+	include/alibabacloud/r-kvstore/model/ReleaseDirectConnectionRequest.h
+	include/alibabacloud/r-kvstore/model/ReleaseDirectConnectionResult.h
 	include/alibabacloud/r-kvstore/model/ReleaseInstancePublicConnectionRequest.h
 	include/alibabacloud/r-kvstore/model/ReleaseInstancePublicConnectionResult.h
 	include/alibabacloud/r-kvstore/model/RenewInstanceRequest.h
@@ -180,6 +188,8 @@ set(r-kvstore_public_header_model
 
 set(r-kvstore_src 
 	src/R-kvstoreClient.cc
+	src/model/AllocateDirectConnectionRequest.cc
+	src/model/AllocateDirectConnectionResult.cc
 	src/model/AllocateInstancePublicConnectionRequest.cc
 	src/model/AllocateInstancePublicConnectionResult.cc
 	src/model/CreateAccountRequest.cc
@@ -192,6 +202,8 @@ set(r-kvstore_src
 	src/model/CreateDedicatedInstanceResult.cc
 	src/model/CreateDedicatedUserClusterRequest.cc
 	src/model/CreateDedicatedUserClusterResult.cc
+	src/model/CreateGlobalDistributeCacheRequest.cc
+	src/model/CreateGlobalDistributeCacheResult.cc
 	src/model/CreateInstanceRequest.cc
 	src/model/CreateInstanceResult.cc
 	src/model/CreateUserClusterHostRequest.cc
@@ -226,6 +238,8 @@ set(r-kvstore_src
 	src/model/DescribeDedicatedClusterInstanceListResult.cc
 	src/model/DescribeDedicatedUserClusterRequest.cc
 	src/model/DescribeDedicatedUserClusterResult.cc
+	src/model/DescribeGlobalDistributeCacheRequest.cc
+	src/model/DescribeGlobalDistributeCacheResult.cc
 	src/model/DescribeHistoryMonitorValuesRequest.cc
 	src/model/DescribeHistoryMonitorValuesResult.cc
 	src/model/DescribeInstanceAttributeRequest.cc
@@ -314,6 +328,8 @@ set(r-kvstore_src
 	src/model/ModifySecurityIpsResult.cc
 	src/model/ModifyUserClusterHostRequest.cc
 	src/model/ModifyUserClusterHostResult.cc
+	src/model/ReleaseDirectConnectionRequest.cc
+	src/model/ReleaseDirectConnectionResult.cc
 	src/model/ReleaseInstancePublicConnectionRequest.cc
 	src/model/ReleaseInstancePublicConnectionResult.cc
 	src/model/RenewInstanceRequest.cc

r-kvstore/include/alibabacloud/r-kvstore/R_kvstoreClient.h

@@ -22,6 +22,8 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "R_kvstoreExport.h"
+#include "model/AllocateDirectConnectionRequest.h"
+#include "model/AllocateDirectConnectionResult.h"
 #include "model/AllocateInstancePublicConnectionRequest.h"
 #include "model/AllocateInstancePublicConnectionResult.h"
 #include "model/CreateAccountRequest.h"
@@ -34,6 +36,8 @@
 #include "model/CreateDedicatedInstanceResult.h"
 #include "model/CreateDedicatedUserClusterRequest.h"
 #include "model/CreateDedicatedUserClusterResult.h"
+#include "model/CreateGlobalDistributeCacheRequest.h"
+#include "model/CreateGlobalDistributeCacheResult.h"
 #include "model/CreateInstanceRequest.h"
 #include "model/CreateInstanceResult.h"
 #include "model/CreateUserClusterHostRequest.h"
@@ -68,6 +72,8 @@
 #include "model/DescribeDedicatedClusterInstanceListResult.h"
 #include "model/DescribeDedicatedUserClusterRequest.h"
 #include "model/DescribeDedicatedUserClusterResult.h"
+#include "model/DescribeGlobalDistributeCacheRequest.h"
+#include "model/DescribeGlobalDistributeCacheResult.h"
 #include "model/DescribeHistoryMonitorValuesRequest.h"
 #include "model/DescribeHistoryMonitorValuesResult.h"
 #include "model/DescribeInstanceAttributeRequest.h"
@@ -156,6 +162,8 @@
 #include "model/ModifySecurityIpsResult.h"
 #include "model/ModifyUserClusterHostRequest.h"
 #include "model/ModifyUserClusterHostResult.h"
+#include "model/ReleaseDirectConnectionRequest.h"
+#include "model/ReleaseDirectConnectionResult.h"
 #include "model/ReleaseInstancePublicConnectionRequest.h"
 #include "model/ReleaseInstancePublicConnectionResult.h"
 #include "model/RenewInstanceRequest.h"
@@ -187,6 +195,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_R_KVSTORE_EXPORT R_kvstoreClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AllocateDirectConnectionResult> AllocateDirectConnectionOutcome;
+			typedef std::future<AllocateDirectConnectionOutcome> AllocateDirectConnectionOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::AllocateDirectConnectionRequest&, const AllocateDirectConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateDirectConnectionAsyncHandler;
 			typedef Outcome<Error, Model::AllocateInstancePublicConnectionResult> AllocateInstancePublicConnectionOutcome;
 			typedef std::future<AllocateInstancePublicConnectionOutcome> AllocateInstancePublicConnectionOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::AllocateInstancePublicConnectionRequest&, const AllocateInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateInstancePublicConnectionAsyncHandler;
@@ -205,6 +216,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateDedicatedUserClusterResult> CreateDedicatedUserClusterOutcome;
 			typedef std::future<CreateDedicatedUserClusterOutcome> CreateDedicatedUserClusterOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::CreateDedicatedUserClusterRequest&, const CreateDedicatedUserClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedUserClusterAsyncHandler;
+			typedef Outcome<Error, Model::CreateGlobalDistributeCacheResult> CreateGlobalDistributeCacheOutcome;
+			typedef std::future<CreateGlobalDistributeCacheOutcome> CreateGlobalDistributeCacheOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::CreateGlobalDistributeCacheRequest&, const CreateGlobalDistributeCacheOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGlobalDistributeCacheAsyncHandler;
 			typedef Outcome<Error, Model::CreateInstanceResult> CreateInstanceOutcome;
 			typedef std::future<CreateInstanceOutcome> CreateInstanceOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::CreateInstanceRequest&, const CreateInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateInstanceAsyncHandler;
@@ -256,6 +270,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDedicatedUserClusterResult> DescribeDedicatedUserClusterOutcome;
 			typedef std::future<DescribeDedicatedUserClusterOutcome> DescribeDedicatedUserClusterOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeDedicatedUserClusterRequest&, const DescribeDedicatedUserClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDedicatedUserClusterAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGlobalDistributeCacheResult> DescribeGlobalDistributeCacheOutcome;
+			typedef std::future<DescribeGlobalDistributeCacheOutcome> DescribeGlobalDistributeCacheOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeGlobalDistributeCacheRequest&, const DescribeGlobalDistributeCacheOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGlobalDistributeCacheAsyncHandler;
 			typedef Outcome<Error, Model::DescribeHistoryMonitorValuesResult> DescribeHistoryMonitorValuesOutcome;
 			typedef std::future<DescribeHistoryMonitorValuesOutcome> DescribeHistoryMonitorValuesOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeHistoryMonitorValuesRequest&, const DescribeHistoryMonitorValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHistoryMonitorValuesAsyncHandler;
@@ -388,6 +405,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyUserClusterHostResult> ModifyUserClusterHostOutcome;
 			typedef std::future<ModifyUserClusterHostOutcome> ModifyUserClusterHostOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::ModifyUserClusterHostRequest&, const ModifyUserClusterHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUserClusterHostAsyncHandler;
+			typedef Outcome<Error, Model::ReleaseDirectConnectionResult> ReleaseDirectConnectionOutcome;
+			typedef std::future<ReleaseDirectConnectionOutcome> ReleaseDirectConnectionOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::ReleaseDirectConnectionRequest&, const ReleaseDirectConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseDirectConnectionAsyncHandler;
 			typedef Outcome<Error, Model::ReleaseInstancePublicConnectionResult> ReleaseInstancePublicConnectionOutcome;
 			typedef std::future<ReleaseInstancePublicConnectionOutcome> ReleaseInstancePublicConnectionOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::ReleaseInstancePublicConnectionRequest&, const ReleaseInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseInstancePublicConnectionAsyncHandler;
@@ -426,6 +446,9 @@ namespace AlibabaCloud
 			R_kvstoreClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			R_kvstoreClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~R_kvstoreClient();
+			AllocateDirectConnectionOutcome allocateDirectConnection(const Model::AllocateDirectConnectionRequest &request)const;
+			void allocateDirectConnectionAsync(const Model::AllocateDirectConnectionRequest& request, const AllocateDirectConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AllocateDirectConnectionOutcomeCallable allocateDirectConnectionCallable(const Model::AllocateDirectConnectionRequest& request) const;
 			AllocateInstancePublicConnectionOutcome allocateInstancePublicConnection(const Model::AllocateInstancePublicConnectionRequest &request)const;
 			void allocateInstancePublicConnectionAsync(const Model::AllocateInstancePublicConnectionRequest& request, const AllocateInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AllocateInstancePublicConnectionOutcomeCallable allocateInstancePublicConnectionCallable(const Model::AllocateInstancePublicConnectionRequest& request) const;
@@ -444,6 +467,9 @@ namespace AlibabaCloud
 			CreateDedicatedUserClusterOutcome createDedicatedUserCluster(const Model::CreateDedicatedUserClusterRequest &request)const;
 			void createDedicatedUserClusterAsync(const Model::CreateDedicatedUserClusterRequest& request, const CreateDedicatedUserClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDedicatedUserClusterOutcomeCallable createDedicatedUserClusterCallable(const Model::CreateDedicatedUserClusterRequest& request) const;
+			CreateGlobalDistributeCacheOutcome createGlobalDistributeCache(const Model::CreateGlobalDistributeCacheRequest &request)const;
+			void createGlobalDistributeCacheAsync(const Model::CreateGlobalDistributeCacheRequest& request, const CreateGlobalDistributeCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGlobalDistributeCacheOutcomeCallable createGlobalDistributeCacheCallable(const Model::CreateGlobalDistributeCacheRequest& request) const;
 			CreateInstanceOutcome createInstance(const Model::CreateInstanceRequest &request)const;
 			void createInstanceAsync(const Model::CreateInstanceRequest& request, const CreateInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateInstanceOutcomeCallable createInstanceCallable(const Model::CreateInstanceRequest& request) const;
@@ -495,6 +521,9 @@ namespace AlibabaCloud
 			DescribeDedicatedUserClusterOutcome describeDedicatedUserCluster(const Model::DescribeDedicatedUserClusterRequest &request)const;
 			void describeDedicatedUserClusterAsync(const Model::DescribeDedicatedUserClusterRequest& request, const DescribeDedicatedUserClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDedicatedUserClusterOutcomeCallable describeDedicatedUserClusterCallable(const Model::DescribeDedicatedUserClusterRequest& request) const;
+			DescribeGlobalDistributeCacheOutcome describeGlobalDistributeCache(const Model::DescribeGlobalDistributeCacheRequest &request)const;
+			void describeGlobalDistributeCacheAsync(const Model::DescribeGlobalDistributeCacheRequest& request, const DescribeGlobalDistributeCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGlobalDistributeCacheOutcomeCallable describeGlobalDistributeCacheCallable(const Model::DescribeGlobalDistributeCacheRequest& request) const;
 			DescribeHistoryMonitorValuesOutcome describeHistoryMonitorValues(const Model::DescribeHistoryMonitorValuesRequest &request)const;
 			void describeHistoryMonitorValuesAsync(const Model::DescribeHistoryMonitorValuesRequest& request, const DescribeHistoryMonitorValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeHistoryMonitorValuesOutcomeCallable describeHistoryMonitorValuesCallable(const Model::DescribeHistoryMonitorValuesRequest& request) const;
@@ -627,6 +656,9 @@ namespace AlibabaCloud
 			ModifyUserClusterHostOutcome modifyUserClusterHost(const Model::ModifyUserClusterHostRequest &request)const;
 			void modifyUserClusterHostAsync(const Model::ModifyUserClusterHostRequest& request, const ModifyUserClusterHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyUserClusterHostOutcomeCallable modifyUserClusterHostCallable(const Model::ModifyUserClusterHostRequest& request) const;
+			ReleaseDirectConnectionOutcome releaseDirectConnection(const Model::ReleaseDirectConnectionRequest &request)const;
+			void releaseDirectConnectionAsync(const Model::ReleaseDirectConnectionRequest& request, const ReleaseDirectConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReleaseDirectConnectionOutcomeCallable releaseDirectConnectionCallable(const Model::ReleaseDirectConnectionRequest& request) const;
 			ReleaseInstancePublicConnectionOutcome releaseInstancePublicConnection(const Model::ReleaseInstancePublicConnectionRequest &request)const;
 			void releaseInstancePublicConnectionAsync(const Model::ReleaseInstancePublicConnectionRequest& request, const ReleaseInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ReleaseInstancePublicConnectionOutcomeCallable releaseInstancePublicConnectionCallable(const Model::ReleaseInstancePublicConnectionRequest& request) const;

r-kvstore/include/alibabacloud/r-kvstore/model/AllocateDirectConnectionRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_ALLOCATEDIRECTCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_ALLOCATEDIRECTCONNECTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT AllocateDirectConnectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				AllocateDirectConnectionRequest();
+				~AllocateDirectConnectionRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getConnectionString()const;
+				void setConnectionString(const std::string& connectionString);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getPort()const;
+				void setPort(const std::string& port);
+
+            private:
+				long resourceOwnerId_;
+				std::string connectionString_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string instanceId_;
+				std::string port_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_ALLOCATEDIRECTCONNECTIONREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/AllocateDirectConnectionResult.h

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

r-kvstore/include/alibabacloud/r-kvstore/model/CreateGlobalDistributeCacheRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_CREATEGLOBALDISTRIBUTECACHEREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_CREATEGLOBALDISTRIBUTECACHEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT CreateGlobalDistributeCacheRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateGlobalDistributeCacheRequest();
+				~CreateGlobalDistributeCacheRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getSeedSubInstanceId()const;
+				void setSeedSubInstanceId(const std::string& seedSubInstanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string seedSubInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_CREATEGLOBALDISTRIBUTECACHEREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/CreateGlobalDistributeCacheResult.h

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

r-kvstore/include/alibabacloud/r-kvstore/model/CreateInstanceRequest.h

@@ -51,6 +51,8 @@ namespace AlibabaCloud
 				void setSecurityToken(const std::string& securityToken);
 				std::string getBusinessInfo()const;
 				void setBusinessInfo(const std::string& businessInfo);
+				int getShardCount()const;
+				void setShardCount(int shardCount);
 				std::string getAutoRenewPeriod()const;
 				void setAutoRenewPeriod(const std::string& autoRenewPeriod);
 				std::string getPeriod()const;
@@ -91,8 +93,12 @@ namespace AlibabaCloud
 				void setSrcDBInstanceId(const std::string& srcDBInstanceId);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				bool getGlobalInstance()const;
+				void setGlobalInstance(bool globalInstance);
 				std::string getToken()const;
 				void setToken(const std::string& token);
+				std::string getGlobalInstanceId()const;
+				void setGlobalInstanceId(const std::string& globalInstanceId);
 				std::string getVpcId()const;
 				void setVpcId(const std::string& vpcId);
 				std::string getChargeType()const;
@@ -109,6 +115,7 @@ namespace AlibabaCloud
 				std::string password_;
 				std::string securityToken_;
 				std::string businessInfo_;
+				int shardCount_;
 				std::string autoRenewPeriod_;
 				std::string period_;
 				std::string backupId_;
@@ -129,7 +136,9 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string srcDBInstanceId_;
 				std::string ownerAccount_;
+				bool globalInstance_;
 				std::string token_;
+				std::string globalInstanceId_;
 				std::string vpcId_;
 				std::string chargeType_;
 				std::string config_;

r-kvstore/include/alibabacloud/r-kvstore/model/DeleteInstanceRequest.h

@@ -37,27 +37,33 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				bool getReleaseSubInstance()const;
+				void setReleaseSubInstance(bool releaseSubInstance);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getGlobalInstanceId()const;
+				void setGlobalInstanceId(const std::string& globalInstanceId);
 				std::string getInstanceId()const;
 				void setInstanceId(const std::string& instanceId);
-				std::string getSecurityToken()const;
-				void setSecurityToken(const std::string& securityToken);
 
             private:
 				long resourceOwnerId_;
+				bool releaseSubInstance_;
+				std::string accessKeyId_;
+				std::string securityToken_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
-				std::string accessKeyId_;
+				std::string globalInstanceId_;
 				std::string instanceId_;
-				std::string securityToken_;
 
 			};
 		}

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeGlobalDistributeCacheRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHEREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT DescribeGlobalDistributeCacheRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeGlobalDistributeCacheRequest();
+				~DescribeGlobalDistributeCacheRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getPageNumber()const;
+				void setPageNumber(const std::string& pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getPageSize()const;
+				void setPageSize(const std::string& pageSize);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getGlobalInstanceId()const;
+				void setGlobalInstanceId(const std::string& globalInstanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string pageNumber_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string pageSize_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string globalInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHEREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeGlobalDistributeCacheResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHERESULT_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT DescribeGlobalDistributeCacheResult : public ServiceResult
+			{
+			public:
+				struct GlobalDistributeCache
+				{
+					struct SubInstance
+					{
+						std::string instanceID;
+						std::string instanceStatus;
+						std::string globalInstanceId;
+						std::string regionId;
+					};
+					std::string status;
+					std::vector<GlobalDistributeCache::SubInstance> subInstances;
+					std::string globalInstanceId;
+					std::string globalInstanceName;
+				};
+
+
+				DescribeGlobalDistributeCacheResult();
+				explicit DescribeGlobalDistributeCacheResult(const std::string &payload);
+				~DescribeGlobalDistributeCacheResult();
+				int getTotalRecordCount()const;
+				std::vector<GlobalDistributeCache> getGlobalDistributeCaches()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalRecordCount_;
+				std::vector<GlobalDistributeCache> globalDistributeCaches_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHERESULT_H_

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeInstancesRequest.h

@@ -73,6 +73,8 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				bool getGlobalInstance()const;
+				void setGlobalInstance(bool globalInstance);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getVSwitchId()const;
@@ -107,6 +109,7 @@ namespace AlibabaCloud
 				std::string instanceStatus_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				bool globalInstance_;
 				long ownerId_;
 				std::string vSwitchId_;
 				int vpcCloudInsInfo_;

r-kvstore/include/alibabacloud/r-kvstore/model/ReleaseDirectConnectionRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_RELEASEDIRECTCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_RELEASEDIRECTCONNECTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT ReleaseDirectConnectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				ReleaseDirectConnectionRequest();
+				~ReleaseDirectConnectionRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_RELEASEDIRECTCONNECTIONREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/ReleaseDirectConnectionResult.h

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

r-kvstore/src/R-kvstoreClient.cc

@@ -51,6 +51,42 @@ R_kvstoreClient::R_kvstoreClient(const std::string & accessKeyId, const std::str
 R_kvstoreClient::~R_kvstoreClient()
 {}
 
+R_kvstoreClient::AllocateDirectConnectionOutcome R_kvstoreClient::allocateDirectConnection(const AllocateDirectConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AllocateDirectConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AllocateDirectConnectionOutcome(AllocateDirectConnectionResult(outcome.result()));
+	else
+		return AllocateDirectConnectionOutcome(outcome.error());
+}
+
+void R_kvstoreClient::allocateDirectConnectionAsync(const AllocateDirectConnectionRequest& request, const AllocateDirectConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, allocateDirectConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::AllocateDirectConnectionOutcomeCallable R_kvstoreClient::allocateDirectConnectionCallable(const AllocateDirectConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AllocateDirectConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->allocateDirectConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::AllocateInstancePublicConnectionOutcome R_kvstoreClient::allocateInstancePublicConnection(const AllocateInstancePublicConnectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,42 @@ R_kvstoreClient::CreateDedicatedUserClusterOutcomeCallable R_kvstoreClient::crea
 	return task->get_future();
 }
 
+R_kvstoreClient::CreateGlobalDistributeCacheOutcome R_kvstoreClient::createGlobalDistributeCache(const CreateGlobalDistributeCacheRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateGlobalDistributeCacheOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateGlobalDistributeCacheOutcome(CreateGlobalDistributeCacheResult(outcome.result()));
+	else
+		return CreateGlobalDistributeCacheOutcome(outcome.error());
+}
+
+void R_kvstoreClient::createGlobalDistributeCacheAsync(const CreateGlobalDistributeCacheRequest& request, const CreateGlobalDistributeCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createGlobalDistributeCache(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::CreateGlobalDistributeCacheOutcomeCallable R_kvstoreClient::createGlobalDistributeCacheCallable(const CreateGlobalDistributeCacheRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateGlobalDistributeCacheOutcome()>>(
+			[this, request]()
+			{
+			return this->createGlobalDistributeCache(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::CreateInstanceOutcome R_kvstoreClient::createInstance(const CreateInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +951,42 @@ R_kvstoreClient::DescribeDedicatedUserClusterOutcomeCallable R_kvstoreClient::de
 	return task->get_future();
 }
 
+R_kvstoreClient::DescribeGlobalDistributeCacheOutcome R_kvstoreClient::describeGlobalDistributeCache(const DescribeGlobalDistributeCacheRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeGlobalDistributeCacheOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeGlobalDistributeCacheOutcome(DescribeGlobalDistributeCacheResult(outcome.result()));
+	else
+		return DescribeGlobalDistributeCacheOutcome(outcome.error());
+}
+
+void R_kvstoreClient::describeGlobalDistributeCacheAsync(const DescribeGlobalDistributeCacheRequest& request, const DescribeGlobalDistributeCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeGlobalDistributeCache(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::DescribeGlobalDistributeCacheOutcomeCallable R_kvstoreClient::describeGlobalDistributeCacheCallable(const DescribeGlobalDistributeCacheRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeGlobalDistributeCacheOutcome()>>(
+			[this, request]()
+			{
+			return this->describeGlobalDistributeCache(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::DescribeHistoryMonitorValuesOutcome R_kvstoreClient::describeHistoryMonitorValues(const DescribeHistoryMonitorValuesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2463,6 +2571,42 @@ R_kvstoreClient::ModifyUserClusterHostOutcomeCallable R_kvstoreClient::modifyUse
 	return task->get_future();
 }
 
+R_kvstoreClient::ReleaseDirectConnectionOutcome R_kvstoreClient::releaseDirectConnection(const ReleaseDirectConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReleaseDirectConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReleaseDirectConnectionOutcome(ReleaseDirectConnectionResult(outcome.result()));
+	else
+		return ReleaseDirectConnectionOutcome(outcome.error());
+}
+
+void R_kvstoreClient::releaseDirectConnectionAsync(const ReleaseDirectConnectionRequest& request, const ReleaseDirectConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, releaseDirectConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::ReleaseDirectConnectionOutcomeCallable R_kvstoreClient::releaseDirectConnectionCallable(const ReleaseDirectConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReleaseDirectConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->releaseDirectConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::ReleaseInstancePublicConnectionOutcome R_kvstoreClient::releaseInstancePublicConnection(const ReleaseInstancePublicConnectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

r-kvstore/src/model/AllocateDirectConnectionRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * 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/r-kvstore/model/AllocateDirectConnectionRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::AllocateDirectConnectionRequest;
+
+AllocateDirectConnectionRequest::AllocateDirectConnectionRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "AllocateDirectConnection")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AllocateDirectConnectionRequest::~AllocateDirectConnectionRequest()
+{}
+
+long AllocateDirectConnectionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AllocateDirectConnectionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AllocateDirectConnectionRequest::getConnectionString()const
+{
+	return connectionString_;
+}
+
+void AllocateDirectConnectionRequest::setConnectionString(const std::string& connectionString)
+{
+	connectionString_ = connectionString;
+	setParameter("ConnectionString", connectionString);
+}
+
+std::string AllocateDirectConnectionRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AllocateDirectConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string AllocateDirectConnectionRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void AllocateDirectConnectionRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string AllocateDirectConnectionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AllocateDirectConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AllocateDirectConnectionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void AllocateDirectConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long AllocateDirectConnectionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AllocateDirectConnectionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string AllocateDirectConnectionRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void AllocateDirectConnectionRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string AllocateDirectConnectionRequest::getPort()const
+{
+	return port_;
+}
+
+void AllocateDirectConnectionRequest::setPort(const std::string& port)
+{
+	port_ = port;
+	setParameter("Port", port);
+}
+

r-kvstore/src/model/AllocateDirectConnectionResult.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/r-kvstore/model/AllocateDirectConnectionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::R_kvstore;
+using namespace AlibabaCloud::R_kvstore::Model;
+
+AllocateDirectConnectionResult::AllocateDirectConnectionResult() :
+	ServiceResult()
+{}
+
+AllocateDirectConnectionResult::AllocateDirectConnectionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AllocateDirectConnectionResult::~AllocateDirectConnectionResult()
+{}
+
+void AllocateDirectConnectionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

r-kvstore/src/model/CreateGlobalDistributeCacheRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * 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/r-kvstore/model/CreateGlobalDistributeCacheRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::CreateGlobalDistributeCacheRequest;
+
+CreateGlobalDistributeCacheRequest::CreateGlobalDistributeCacheRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "CreateGlobalDistributeCache")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateGlobalDistributeCacheRequest::~CreateGlobalDistributeCacheRequest()
+{}
+
+long CreateGlobalDistributeCacheRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateGlobalDistributeCacheRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateGlobalDistributeCacheRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateGlobalDistributeCacheRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateGlobalDistributeCacheRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void CreateGlobalDistributeCacheRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string CreateGlobalDistributeCacheRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateGlobalDistributeCacheRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateGlobalDistributeCacheRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateGlobalDistributeCacheRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateGlobalDistributeCacheRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateGlobalDistributeCacheRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateGlobalDistributeCacheRequest::getSeedSubInstanceId()const
+{
+	return seedSubInstanceId_;
+}
+
+void CreateGlobalDistributeCacheRequest::setSeedSubInstanceId(const std::string& seedSubInstanceId)
+{
+	seedSubInstanceId_ = seedSubInstanceId;
+	setParameter("SeedSubInstanceId", seedSubInstanceId);
+}
+

r-kvstore/src/model/CreateGlobalDistributeCacheResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/r-kvstore/model/CreateGlobalDistributeCacheResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::R_kvstore;
+using namespace AlibabaCloud::R_kvstore::Model;
+
+CreateGlobalDistributeCacheResult::CreateGlobalDistributeCacheResult() :
+	ServiceResult()
+{}
+
+CreateGlobalDistributeCacheResult::CreateGlobalDistributeCacheResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateGlobalDistributeCacheResult::~CreateGlobalDistributeCacheResult()
+{}
+
+void CreateGlobalDistributeCacheResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["GlobalInstanceId"].isNull())
+		globalInstanceId_ = value["GlobalInstanceId"].asString();
+
+}
+
+std::string CreateGlobalDistributeCacheResult::getGlobalInstanceId()const
+{
+	return globalInstanceId_;
+}
+

r-kvstore/src/model/CreateInstanceRequest.cc

@@ -115,6 +115,17 @@ void CreateInstanceRequest::setBusinessInfo(const std::string& businessInfo)
 	setParameter("BusinessInfo", businessInfo);
 }
 
+int CreateInstanceRequest::getShardCount()const
+{
+	return shardCount_;
+}
+
+void CreateInstanceRequest::setShardCount(int shardCount)
+{
+	shardCount_ = shardCount;
+	setParameter("ShardCount", std::to_string(shardCount));
+}
+
 std::string CreateInstanceRequest::getAutoRenewPeriod()const
 {
 	return autoRenewPeriod_;
@@ -335,6 +346,17 @@ void CreateInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+bool CreateInstanceRequest::getGlobalInstance()const
+{
+	return globalInstance_;
+}
+
+void CreateInstanceRequest::setGlobalInstance(bool globalInstance)
+{
+	globalInstance_ = globalInstance;
+	setParameter("GlobalInstance", globalInstance ? "true" : "false");
+}
+
 std::string CreateInstanceRequest::getToken()const
 {
 	return token_;
@@ -346,6 +368,17 @@ void CreateInstanceRequest::setToken(const std::string& token)
 	setParameter("Token", token);
 }
 
+std::string CreateInstanceRequest::getGlobalInstanceId()const
+{
+	return globalInstanceId_;
+}
+
+void CreateInstanceRequest::setGlobalInstanceId(const std::string& globalInstanceId)
+{
+	globalInstanceId_ = globalInstanceId;
+	setParameter("GlobalInstanceId", globalInstanceId);
+}
+
 std::string CreateInstanceRequest::getVpcId()const
 {
 	return vpcId_;

r-kvstore/src/model/DeleteInstanceRequest.cc

@@ -38,6 +38,39 @@ void DeleteInstanceRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+bool DeleteInstanceRequest::getReleaseSubInstance()const
+{
+	return releaseSubInstance_;
+}
+
+void DeleteInstanceRequest::setReleaseSubInstance(bool releaseSubInstance)
+{
+	releaseSubInstance_ = releaseSubInstance;
+	setParameter("ReleaseSubInstance", releaseSubInstance ? "true" : "false");
+}
+
+std::string DeleteInstanceRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DeleteInstanceRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DeleteInstanceRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
 std::string DeleteInstanceRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -71,15 +104,15 @@ void DeleteInstanceRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
-std::string DeleteInstanceRequest::getAccessKeyId()const
+std::string DeleteInstanceRequest::getGlobalInstanceId()const
 {
-	return accessKeyId_;
+	return globalInstanceId_;
 }
 
-void DeleteInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
+void DeleteInstanceRequest::setGlobalInstanceId(const std::string& globalInstanceId)
 {
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	globalInstanceId_ = globalInstanceId;
+	setParameter("GlobalInstanceId", globalInstanceId);
 }
 
 std::string DeleteInstanceRequest::getInstanceId()const
@@ -93,14 +126,3 @@ void DeleteInstanceRequest::setInstanceId(const std::string& instanceId)
 	setParameter("InstanceId", instanceId);
 }
 
-std::string DeleteInstanceRequest::getSecurityToken()const
-{
-	return securityToken_;
-}
-
-void DeleteInstanceRequest::setSecurityToken(const std::string& securityToken)
-{
-	securityToken_ = securityToken;
-	setParameter("SecurityToken", securityToken);
-}
-

r-kvstore/src/model/DescribeGlobalDistributeCacheRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * 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/r-kvstore/model/DescribeGlobalDistributeCacheRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::DescribeGlobalDistributeCacheRequest;
+
+DescribeGlobalDistributeCacheRequest::DescribeGlobalDistributeCacheRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "DescribeGlobalDistributeCache")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeGlobalDistributeCacheRequest::~DescribeGlobalDistributeCacheRequest()
+{}
+
+long DescribeGlobalDistributeCacheRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeGlobalDistributeCacheRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setPageNumber(const std::string& pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", pageNumber);
+}
+
+std::string DescribeGlobalDistributeCacheRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeGlobalDistributeCacheRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeGlobalDistributeCacheRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setPageSize(const std::string& pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", pageSize);
+}
+
+std::string DescribeGlobalDistributeCacheRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeGlobalDistributeCacheRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeGlobalDistributeCacheRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeGlobalDistributeCacheRequest::getGlobalInstanceId()const
+{
+	return globalInstanceId_;
+}
+
+void DescribeGlobalDistributeCacheRequest::setGlobalInstanceId(const std::string& globalInstanceId)
+{
+	globalInstanceId_ = globalInstanceId;
+	setParameter("GlobalInstanceId", globalInstanceId);
+}
+

r-kvstore/src/model/DescribeGlobalDistributeCacheResult.cc

@@ -0,0 +1,96 @@
+/*
+ * 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/r-kvstore/model/DescribeGlobalDistributeCacheResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::R_kvstore;
+using namespace AlibabaCloud::R_kvstore::Model;
+
+DescribeGlobalDistributeCacheResult::DescribeGlobalDistributeCacheResult() :
+	ServiceResult()
+{}
+
+DescribeGlobalDistributeCacheResult::DescribeGlobalDistributeCacheResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGlobalDistributeCacheResult::~DescribeGlobalDistributeCacheResult()
+{}
+
+void DescribeGlobalDistributeCacheResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allGlobalDistributeCachesNode = value["GlobalDistributeCaches"]["GlobalDistributeCache"];
+	for (auto valueGlobalDistributeCachesGlobalDistributeCache : allGlobalDistributeCachesNode)
+	{
+		GlobalDistributeCache globalDistributeCachesObject;
+		if(!valueGlobalDistributeCachesGlobalDistributeCache["GlobalInstanceId"].isNull())
+			globalDistributeCachesObject.globalInstanceId = valueGlobalDistributeCachesGlobalDistributeCache["GlobalInstanceId"].asString();
+		if(!valueGlobalDistributeCachesGlobalDistributeCache["GlobalInstanceName"].isNull())
+			globalDistributeCachesObject.globalInstanceName = valueGlobalDistributeCachesGlobalDistributeCache["GlobalInstanceName"].asString();
+		if(!valueGlobalDistributeCachesGlobalDistributeCache["Status"].isNull())
+			globalDistributeCachesObject.status = valueGlobalDistributeCachesGlobalDistributeCache["Status"].asString();
+		auto allSubInstancesNode = allGlobalDistributeCachesNode["SubInstances"]["SubInstance"];
+		for (auto allGlobalDistributeCachesNodeSubInstancesSubInstance : allSubInstancesNode)
+		{
+			GlobalDistributeCache::SubInstance subInstancesObject;
+			if(!allGlobalDistributeCachesNodeSubInstancesSubInstance["GlobalInstanceId"].isNull())
+				subInstancesObject.globalInstanceId = allGlobalDistributeCachesNodeSubInstancesSubInstance["GlobalInstanceId"].asString();
+			if(!allGlobalDistributeCachesNodeSubInstancesSubInstance["InstanceID"].isNull())
+				subInstancesObject.instanceID = allGlobalDistributeCachesNodeSubInstancesSubInstance["InstanceID"].asString();
+			if(!allGlobalDistributeCachesNodeSubInstancesSubInstance["RegionId"].isNull())
+				subInstancesObject.regionId = allGlobalDistributeCachesNodeSubInstancesSubInstance["RegionId"].asString();
+			if(!allGlobalDistributeCachesNodeSubInstancesSubInstance["InstanceStatus"].isNull())
+				subInstancesObject.instanceStatus = allGlobalDistributeCachesNodeSubInstancesSubInstance["InstanceStatus"].asString();
+			globalDistributeCachesObject.subInstances.push_back(subInstancesObject);
+		}
+		globalDistributeCaches_.push_back(globalDistributeCachesObject);
+	}
+	if(!value["TotalRecordCount"].isNull())
+		totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int DescribeGlobalDistributeCacheResult::getTotalRecordCount()const
+{
+	return totalRecordCount_;
+}
+
+std::vector<DescribeGlobalDistributeCacheResult::GlobalDistributeCache> DescribeGlobalDistributeCacheResult::getGlobalDistributeCaches()const
+{
+	return globalDistributeCaches_;
+}
+
+int DescribeGlobalDistributeCacheResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeGlobalDistributeCacheResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

r-kvstore/src/model/DescribeInstancesRequest.cc

@@ -208,6 +208,17 @@ void DescribeInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+bool DescribeInstancesRequest::getGlobalInstance()const
+{
+	return globalInstance_;
+}
+
+void DescribeInstancesRequest::setGlobalInstance(bool globalInstance)
+{
+	globalInstance_ = globalInstance;
+	setParameter("GlobalInstance", globalInstance ? "true" : "false");
+}
+
 long DescribeInstancesRequest::getOwnerId()const
 {
 	return ownerId_;

r-kvstore/src/model/ReleaseDirectConnectionRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * 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/r-kvstore/model/ReleaseDirectConnectionRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::ReleaseDirectConnectionRequest;
+
+ReleaseDirectConnectionRequest::ReleaseDirectConnectionRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "ReleaseDirectConnection")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ReleaseDirectConnectionRequest::~ReleaseDirectConnectionRequest()
+{}
+
+long ReleaseDirectConnectionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ReleaseDirectConnectionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ReleaseDirectConnectionRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ReleaseDirectConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ReleaseDirectConnectionRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void ReleaseDirectConnectionRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string ReleaseDirectConnectionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ReleaseDirectConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ReleaseDirectConnectionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ReleaseDirectConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long ReleaseDirectConnectionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ReleaseDirectConnectionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ReleaseDirectConnectionRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ReleaseDirectConnectionRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

r-kvstore/src/model/ReleaseDirectConnectionResult.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/r-kvstore/model/ReleaseDirectConnectionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::R_kvstore;
+using namespace AlibabaCloud::R_kvstore::Model;
+
+ReleaseDirectConnectionResult::ReleaseDirectConnectionResult() :
+	ServiceResult()
+{}
+
+ReleaseDirectConnectionResult::ReleaseDirectConnectionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ReleaseDirectConnectionResult::~ReleaseDirectConnectionResult()
+{}
+
+void ReleaseDirectConnectionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+