diff --git a/VERSION b/VERSION index f2051586c..933ddff7a 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1581 \ No newline at end of file +1.36.1582 \ No newline at end of file diff --git a/polardb/CMakeLists.txt b/polardb/CMakeLists.txt index f49548c51..35a9eab51 100644 --- a/polardb/CMakeLists.txt +++ b/polardb/CMakeLists.txt @@ -27,6 +27,8 @@ set(polardb_public_header_model include/alibabacloud/polardb/model/CheckAccountNameResult.h include/alibabacloud/polardb/model/CheckDBNameRequest.h include/alibabacloud/polardb/model/CheckDBNameResult.h + include/alibabacloud/polardb/model/CheckKMSAuthorizedRequest.h + include/alibabacloud/polardb/model/CheckKMSAuthorizedResult.h include/alibabacloud/polardb/model/CloseAITaskRequest.h include/alibabacloud/polardb/model/CloseAITaskResult.h include/alibabacloud/polardb/model/CloseDBClusterMigrationRequest.h @@ -105,6 +107,8 @@ set(polardb_public_header_model include/alibabacloud/polardb/model/DescribeDBClusterAuditLogCollectorResult.h include/alibabacloud/polardb/model/DescribeDBClusterAvailableResourcesRequest.h include/alibabacloud/polardb/model/DescribeDBClusterAvailableResourcesResult.h + include/alibabacloud/polardb/model/DescribeDBClusterConnectivityRequest.h + include/alibabacloud/polardb/model/DescribeDBClusterConnectivityResult.h include/alibabacloud/polardb/model/DescribeDBClusterEndpointsRequest.h include/alibabacloud/polardb/model/DescribeDBClusterEndpointsResult.h include/alibabacloud/polardb/model/DescribeDBClusterMigrationRequest.h @@ -177,6 +181,8 @@ set(polardb_public_header_model include/alibabacloud/polardb/model/DescribeSlowLogsResult.h include/alibabacloud/polardb/model/DescribeTasksRequest.h include/alibabacloud/polardb/model/DescribeTasksResult.h + include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListRequest.h + include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListResult.h include/alibabacloud/polardb/model/DescribeVSwitchesRequest.h include/alibabacloud/polardb/model/DescribeVSwitchesResult.h include/alibabacloud/polardb/model/EnableFirewallRulesRequest.h @@ -189,6 +195,8 @@ set(polardb_public_header_model include/alibabacloud/polardb/model/GrantAccountPrivilegeResult.h include/alibabacloud/polardb/model/ListTagResourcesRequest.h include/alibabacloud/polardb/model/ListTagResourcesResult.h + include/alibabacloud/polardb/model/ManuallyStartDBClusterRequest.h + include/alibabacloud/polardb/model/ManuallyStartDBClusterResult.h include/alibabacloud/polardb/model/ModifyAccountDescriptionRequest.h include/alibabacloud/polardb/model/ModifyAccountDescriptionResult.h include/alibabacloud/polardb/model/ModifyAccountPasswordRequest.h @@ -292,6 +300,8 @@ set(polardb_src src/model/CheckAccountNameResult.cc src/model/CheckDBNameRequest.cc src/model/CheckDBNameResult.cc + src/model/CheckKMSAuthorizedRequest.cc + src/model/CheckKMSAuthorizedResult.cc src/model/CloseAITaskRequest.cc src/model/CloseAITaskResult.cc src/model/CloseDBClusterMigrationRequest.cc @@ -370,6 +380,8 @@ set(polardb_src src/model/DescribeDBClusterAuditLogCollectorResult.cc src/model/DescribeDBClusterAvailableResourcesRequest.cc src/model/DescribeDBClusterAvailableResourcesResult.cc + src/model/DescribeDBClusterConnectivityRequest.cc + src/model/DescribeDBClusterConnectivityResult.cc src/model/DescribeDBClusterEndpointsRequest.cc src/model/DescribeDBClusterEndpointsResult.cc src/model/DescribeDBClusterMigrationRequest.cc @@ -442,6 +454,8 @@ set(polardb_src src/model/DescribeSlowLogsResult.cc src/model/DescribeTasksRequest.cc src/model/DescribeTasksResult.cc + src/model/DescribeUserEncryptionKeyListRequest.cc + src/model/DescribeUserEncryptionKeyListResult.cc src/model/DescribeVSwitchesRequest.cc src/model/DescribeVSwitchesResult.cc src/model/EnableFirewallRulesRequest.cc @@ -454,6 +468,8 @@ set(polardb_src src/model/GrantAccountPrivilegeResult.cc src/model/ListTagResourcesRequest.cc src/model/ListTagResourcesResult.cc + src/model/ManuallyStartDBClusterRequest.cc + src/model/ManuallyStartDBClusterResult.cc src/model/ModifyAccountDescriptionRequest.cc src/model/ModifyAccountDescriptionResult.cc src/model/ModifyAccountPasswordRequest.cc diff --git a/polardb/include/alibabacloud/polardb/PolardbClient.h b/polardb/include/alibabacloud/polardb/PolardbClient.h index ba37ca724..d1cad0fd9 100644 --- a/polardb/include/alibabacloud/polardb/PolardbClient.h +++ b/polardb/include/alibabacloud/polardb/PolardbClient.h @@ -28,6 +28,8 @@ #include "model/CheckAccountNameResult.h" #include "model/CheckDBNameRequest.h" #include "model/CheckDBNameResult.h" +#include "model/CheckKMSAuthorizedRequest.h" +#include "model/CheckKMSAuthorizedResult.h" #include "model/CloseAITaskRequest.h" #include "model/CloseAITaskResult.h" #include "model/CloseDBClusterMigrationRequest.h" @@ -106,6 +108,8 @@ #include "model/DescribeDBClusterAuditLogCollectorResult.h" #include "model/DescribeDBClusterAvailableResourcesRequest.h" #include "model/DescribeDBClusterAvailableResourcesResult.h" +#include "model/DescribeDBClusterConnectivityRequest.h" +#include "model/DescribeDBClusterConnectivityResult.h" #include "model/DescribeDBClusterEndpointsRequest.h" #include "model/DescribeDBClusterEndpointsResult.h" #include "model/DescribeDBClusterMigrationRequest.h" @@ -178,6 +182,8 @@ #include "model/DescribeSlowLogsResult.h" #include "model/DescribeTasksRequest.h" #include "model/DescribeTasksResult.h" +#include "model/DescribeUserEncryptionKeyListRequest.h" +#include "model/DescribeUserEncryptionKeyListResult.h" #include "model/DescribeVSwitchesRequest.h" #include "model/DescribeVSwitchesResult.h" #include "model/EnableFirewallRulesRequest.h" @@ -190,6 +196,8 @@ #include "model/GrantAccountPrivilegeResult.h" #include "model/ListTagResourcesRequest.h" #include "model/ListTagResourcesResult.h" +#include "model/ManuallyStartDBClusterRequest.h" +#include "model/ManuallyStartDBClusterResult.h" #include "model/ModifyAccountDescriptionRequest.h" #include "model/ModifyAccountDescriptionResult.h" #include "model/ModifyAccountPasswordRequest.h" @@ -302,6 +310,9 @@ namespace AlibabaCloud typedef Outcome CheckDBNameOutcome; typedef std::future CheckDBNameOutcomeCallable; typedef std::function&)> CheckDBNameAsyncHandler; + typedef Outcome CheckKMSAuthorizedOutcome; + typedef std::future CheckKMSAuthorizedOutcomeCallable; + typedef std::function&)> CheckKMSAuthorizedAsyncHandler; typedef Outcome CloseAITaskOutcome; typedef std::future CloseAITaskOutcomeCallable; typedef std::function&)> CloseAITaskAsyncHandler; @@ -419,6 +430,9 @@ namespace AlibabaCloud typedef Outcome DescribeDBClusterAvailableResourcesOutcome; typedef std::future DescribeDBClusterAvailableResourcesOutcomeCallable; typedef std::function&)> DescribeDBClusterAvailableResourcesAsyncHandler; + typedef Outcome DescribeDBClusterConnectivityOutcome; + typedef std::future DescribeDBClusterConnectivityOutcomeCallable; + typedef std::function&)> DescribeDBClusterConnectivityAsyncHandler; typedef Outcome DescribeDBClusterEndpointsOutcome; typedef std::future DescribeDBClusterEndpointsOutcomeCallable; typedef std::function&)> DescribeDBClusterEndpointsAsyncHandler; @@ -527,6 +541,9 @@ namespace AlibabaCloud typedef Outcome DescribeTasksOutcome; typedef std::future DescribeTasksOutcomeCallable; typedef std::function&)> DescribeTasksAsyncHandler; + typedef Outcome DescribeUserEncryptionKeyListOutcome; + typedef std::future DescribeUserEncryptionKeyListOutcomeCallable; + typedef std::function&)> DescribeUserEncryptionKeyListAsyncHandler; typedef Outcome DescribeVSwitchesOutcome; typedef std::future DescribeVSwitchesOutcomeCallable; typedef std::function&)> DescribeVSwitchesAsyncHandler; @@ -545,6 +562,9 @@ namespace AlibabaCloud typedef Outcome ListTagResourcesOutcome; typedef std::future ListTagResourcesOutcomeCallable; typedef std::function&)> ListTagResourcesAsyncHandler; + typedef Outcome ManuallyStartDBClusterOutcome; + typedef std::future ManuallyStartDBClusterOutcomeCallable; + typedef std::function&)> ManuallyStartDBClusterAsyncHandler; typedef Outcome ModifyAccountDescriptionOutcome; typedef std::future ModifyAccountDescriptionOutcomeCallable; typedef std::function&)> ModifyAccountDescriptionAsyncHandler; @@ -700,6 +720,9 @@ namespace AlibabaCloud CheckDBNameOutcome checkDBName(const Model::CheckDBNameRequest &request)const; void checkDBNameAsync(const Model::CheckDBNameRequest& request, const CheckDBNameAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CheckDBNameOutcomeCallable checkDBNameCallable(const Model::CheckDBNameRequest& request) const; + CheckKMSAuthorizedOutcome checkKMSAuthorized(const Model::CheckKMSAuthorizedRequest &request)const; + void checkKMSAuthorizedAsync(const Model::CheckKMSAuthorizedRequest& request, const CheckKMSAuthorizedAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CheckKMSAuthorizedOutcomeCallable checkKMSAuthorizedCallable(const Model::CheckKMSAuthorizedRequest& request) const; CloseAITaskOutcome closeAITask(const Model::CloseAITaskRequest &request)const; void closeAITaskAsync(const Model::CloseAITaskRequest& request, const CloseAITaskAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CloseAITaskOutcomeCallable closeAITaskCallable(const Model::CloseAITaskRequest& request) const; @@ -817,6 +840,9 @@ namespace AlibabaCloud DescribeDBClusterAvailableResourcesOutcome describeDBClusterAvailableResources(const Model::DescribeDBClusterAvailableResourcesRequest &request)const; void describeDBClusterAvailableResourcesAsync(const Model::DescribeDBClusterAvailableResourcesRequest& request, const DescribeDBClusterAvailableResourcesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeDBClusterAvailableResourcesOutcomeCallable describeDBClusterAvailableResourcesCallable(const Model::DescribeDBClusterAvailableResourcesRequest& request) const; + DescribeDBClusterConnectivityOutcome describeDBClusterConnectivity(const Model::DescribeDBClusterConnectivityRequest &request)const; + void describeDBClusterConnectivityAsync(const Model::DescribeDBClusterConnectivityRequest& request, const DescribeDBClusterConnectivityAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeDBClusterConnectivityOutcomeCallable describeDBClusterConnectivityCallable(const Model::DescribeDBClusterConnectivityRequest& request) const; DescribeDBClusterEndpointsOutcome describeDBClusterEndpoints(const Model::DescribeDBClusterEndpointsRequest &request)const; void describeDBClusterEndpointsAsync(const Model::DescribeDBClusterEndpointsRequest& request, const DescribeDBClusterEndpointsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeDBClusterEndpointsOutcomeCallable describeDBClusterEndpointsCallable(const Model::DescribeDBClusterEndpointsRequest& request) const; @@ -925,6 +951,9 @@ namespace AlibabaCloud DescribeTasksOutcome describeTasks(const Model::DescribeTasksRequest &request)const; void describeTasksAsync(const Model::DescribeTasksRequest& request, const DescribeTasksAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeTasksOutcomeCallable describeTasksCallable(const Model::DescribeTasksRequest& request) const; + DescribeUserEncryptionKeyListOutcome describeUserEncryptionKeyList(const Model::DescribeUserEncryptionKeyListRequest &request)const; + void describeUserEncryptionKeyListAsync(const Model::DescribeUserEncryptionKeyListRequest& request, const DescribeUserEncryptionKeyListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeUserEncryptionKeyListOutcomeCallable describeUserEncryptionKeyListCallable(const Model::DescribeUserEncryptionKeyListRequest& request) const; DescribeVSwitchesOutcome describeVSwitches(const Model::DescribeVSwitchesRequest &request)const; void describeVSwitchesAsync(const Model::DescribeVSwitchesRequest& request, const DescribeVSwitchesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeVSwitchesOutcomeCallable describeVSwitchesCallable(const Model::DescribeVSwitchesRequest& request) const; @@ -943,6 +972,9 @@ namespace AlibabaCloud ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const; void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const; + ManuallyStartDBClusterOutcome manuallyStartDBCluster(const Model::ManuallyStartDBClusterRequest &request)const; + void manuallyStartDBClusterAsync(const Model::ManuallyStartDBClusterRequest& request, const ManuallyStartDBClusterAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ManuallyStartDBClusterOutcomeCallable manuallyStartDBClusterCallable(const Model::ManuallyStartDBClusterRequest& request) const; ModifyAccountDescriptionOutcome modifyAccountDescription(const Model::ModifyAccountDescriptionRequest &request)const; void modifyAccountDescriptionAsync(const Model::ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ModifyAccountDescriptionOutcomeCallable modifyAccountDescriptionCallable(const Model::ModifyAccountDescriptionRequest& request) const; diff --git a/polardb/include/alibabacloud/polardb/model/CheckKMSAuthorizedRequest.h b/polardb/include/alibabacloud/polardb/model/CheckKMSAuthorizedRequest.h new file mode 100644 index 000000000..6e943effb --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/CheckKMSAuthorizedRequest.h @@ -0,0 +1,63 @@ +/* + * 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_POLARDB_MODEL_CHECKKMSAUTHORIZEDREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_CHECKKMSAUTHORIZEDREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Polardb { +namespace Model { +class ALIBABACLOUD_POLARDB_EXPORT CheckKMSAuthorizedRequest : public RpcServiceRequest { +public: + CheckKMSAuthorizedRequest(); + ~CheckKMSAuthorizedRequest(); + long getResourceOwnerId() const; + void setResourceOwnerId(long resourceOwnerId); + std::string getAccessKeyId() const; + void setAccessKeyId(const std::string &accessKeyId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getResourceOwnerAccount() const; + void setResourceOwnerAccount(const std::string &resourceOwnerAccount); + std::string getDBClusterId() const; + void setDBClusterId(const std::string &dBClusterId); + std::string getOwnerAccount() const; + void setOwnerAccount(const std::string &ownerAccount); + long getOwnerId() const; + void setOwnerId(long ownerId); + std::string getTDERegion() const; + void setTDERegion(const std::string &tDERegion); + +private: + long resourceOwnerId_; + std::string accessKeyId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string dBClusterId_; + std::string ownerAccount_; + long ownerId_; + std::string tDERegion_; +}; +} // namespace Model +} // namespace Polardb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_POLARDB_MODEL_CHECKKMSAUTHORIZEDREQUEST_H_ diff --git a/polardb/include/alibabacloud/polardb/model/CheckKMSAuthorizedResult.h b/polardb/include/alibabacloud/polardb/model/CheckKMSAuthorizedResult.h new file mode 100644 index 000000000..3bbdbeb3c --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/CheckKMSAuthorizedResult.h @@ -0,0 +1,55 @@ +/* + * 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_POLARDB_MODEL_CHECKKMSAUTHORIZEDRESULT_H_ +#define ALIBABACLOUD_POLARDB_MODEL_CHECKKMSAUTHORIZEDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Polardb + { + namespace Model + { + class ALIBABACLOUD_POLARDB_EXPORT CheckKMSAuthorizedResult : public ServiceResult + { + public: + + + CheckKMSAuthorizedResult(); + explicit CheckKMSAuthorizedResult(const std::string &payload); + ~CheckKMSAuthorizedResult(); + int getAuthorizationState()const; + std::string getDBClusterId()const; + std::string getRoleArn()const; + + protected: + void parse(const std::string &payload); + private: + int authorizationState_; + std::string dBClusterId_; + std::string roleArn_; + + }; + } + } +} +#endif // !ALIBABACLOUD_POLARDB_MODEL_CHECKKMSAUTHORIZEDRESULT_H_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/CreateDBClusterRequest.h b/polardb/include/alibabacloud/polardb/model/CreateDBClusterRequest.h index 148899737..d4294e084 100644 --- a/polardb/include/alibabacloud/polardb/model/CreateDBClusterRequest.h +++ b/polardb/include/alibabacloud/polardb/model/CreateDBClusterRequest.h @@ -104,10 +104,16 @@ public: void setEngine(const std::string &engine); std::string getGDNId() const; void setGDNId(const std::string &gDNId); + std::string getLooseXEngine() const; + void setLooseXEngine(const std::string &looseXEngine); + std::string getLoosePolarLogBin() const; + void setLoosePolarLogBin(const std::string &loosePolarLogBin); std::string getResourceOwnerAccount() const; void setResourceOwnerAccount(const std::string &resourceOwnerAccount); std::string getOwnerAccount() const; void setOwnerAccount(const std::string &ownerAccount); + std::string getLooseXEngineUseMemoryPct() const; + void setLooseXEngineUseMemoryPct(const std::string &looseXEngineUseMemoryPct); std::string getUsedTime() const; void setUsedTime(const std::string &usedTime); int getDBNodeNum() const; @@ -167,8 +173,11 @@ private: std::string regionId_; std::string engine_; std::string gDNId_; + std::string looseXEngine_; + std::string loosePolarLogBin_; std::string resourceOwnerAccount_; std::string ownerAccount_; + std::string looseXEngineUseMemoryPct_; std::string usedTime_; int dBNodeNum_; std::string vPCId_; diff --git a/polardb/include/alibabacloud/polardb/model/DescribeDBClusterConnectivityRequest.h b/polardb/include/alibabacloud/polardb/model/DescribeDBClusterConnectivityRequest.h new file mode 100644 index 000000000..6de4e0aa2 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeDBClusterConnectivityRequest.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_POLARDB_MODEL_DESCRIBEDBCLUSTERCONNECTIVITYREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERCONNECTIVITYREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Polardb { +namespace Model { +class ALIBABACLOUD_POLARDB_EXPORT DescribeDBClusterConnectivityRequest : public RpcServiceRequest { +public: + DescribeDBClusterConnectivityRequest(); + ~DescribeDBClusterConnectivityRequest(); + long getResourceOwnerId() const; + void setResourceOwnerId(long resourceOwnerId); + std::string getAccessKeyId() const; + void setAccessKeyId(const std::string &accessKeyId); + std::string getResourceGroupId() const; + void setResourceGroupId(const std::string &resourceGroupId); + std::string getSecurityToken() const; + void setSecurityToken(const std::string &securityToken); + std::string getSourceIpAddress() const; + void setSourceIpAddress(const std::string &sourceIpAddress); + std::string getResourceOwnerAccount() const; + void setResourceOwnerAccount(const std::string &resourceOwnerAccount); + std::string getDBClusterId() const; + void setDBClusterId(const std::string &dBClusterId); + std::string getOwnerAccount() const; + void setOwnerAccount(const std::string &ownerAccount); + long getOwnerId() const; + void setOwnerId(long ownerId); + +private: + long resourceOwnerId_; + std::string accessKeyId_; + std::string resourceGroupId_; + std::string securityToken_; + std::string sourceIpAddress_; + std::string resourceOwnerAccount_; + std::string dBClusterId_; + std::string ownerAccount_; + long ownerId_; +}; +} // namespace Model +} // namespace Polardb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERCONNECTIVITYREQUEST_H_ diff --git a/polardb/include/alibabacloud/polardb/model/DescribeDBClusterConnectivityResult.h b/polardb/include/alibabacloud/polardb/model/DescribeDBClusterConnectivityResult.h new file mode 100644 index 000000000..581731e7f --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeDBClusterConnectivityResult.h @@ -0,0 +1,57 @@ +/* + * 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_POLARDB_MODEL_DESCRIBEDBCLUSTERCONNECTIVITYRESULT_H_ +#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERCONNECTIVITYRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Polardb + { + namespace Model + { + class ALIBABACLOUD_POLARDB_EXPORT DescribeDBClusterConnectivityResult : public ServiceResult + { + public: + + + DescribeDBClusterConnectivityResult(); + explicit DescribeDBClusterConnectivityResult(const std::string &payload); + ~DescribeDBClusterConnectivityResult(); + std::string getConnCheckErrorCode()const; + std::string getConnCheckResult()const; + std::string getConnCheckErrorMessage()const; + std::string getDBClusterId()const; + + protected: + void parse(const std::string &payload); + private: + std::string connCheckErrorCode_; + std::string connCheckResult_; + std::string connCheckErrorMessage_; + std::string dBClusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERCONNECTIVITYRESULT_H_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListRequest.h b/polardb/include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListRequest.h new file mode 100644 index 000000000..6c87d2e5c --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListRequest.h @@ -0,0 +1,63 @@ +/* + * 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_POLARDB_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Polardb { +namespace Model { +class ALIBABACLOUD_POLARDB_EXPORT DescribeUserEncryptionKeyListRequest : public RpcServiceRequest { +public: + DescribeUserEncryptionKeyListRequest(); + ~DescribeUserEncryptionKeyListRequest(); + long getResourceOwnerId() const; + void setResourceOwnerId(long resourceOwnerId); + std::string getAccessKeyId() const; + void setAccessKeyId(const std::string &accessKeyId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getResourceOwnerAccount() const; + void setResourceOwnerAccount(const std::string &resourceOwnerAccount); + std::string getDBClusterId() const; + void setDBClusterId(const std::string &dBClusterId); + std::string getOwnerAccount() const; + void setOwnerAccount(const std::string &ownerAccount); + long getOwnerId() const; + void setOwnerId(long ownerId); + std::string getTDERegion() const; + void setTDERegion(const std::string &tDERegion); + +private: + long resourceOwnerId_; + std::string accessKeyId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string dBClusterId_; + std::string ownerAccount_; + long ownerId_; + std::string tDERegion_; +}; +} // namespace Model +} // namespace Polardb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_ diff --git a/polardb/include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListResult.h b/polardb/include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListResult.h new file mode 100644 index 000000000..e34241716 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListResult.h @@ -0,0 +1,53 @@ +/* + * 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_POLARDB_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTRESULT_H_ +#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Polardb + { + namespace Model + { + class ALIBABACLOUD_POLARDB_EXPORT DescribeUserEncryptionKeyListResult : public ServiceResult + { + public: + + + DescribeUserEncryptionKeyListResult(); + explicit DescribeUserEncryptionKeyListResult(const std::string &payload); + ~DescribeUserEncryptionKeyListResult(); + std::vector getKeyList()const; + std::string getDBClusterId()const; + + protected: + void parse(const std::string &payload); + private: + std::vector keyList_; + std::string dBClusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTRESULT_H_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/ManuallyStartDBClusterRequest.h b/polardb/include/alibabacloud/polardb/model/ManuallyStartDBClusterRequest.h new file mode 100644 index 000000000..119ba201d --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/ManuallyStartDBClusterRequest.h @@ -0,0 +1,60 @@ +/* + * 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_POLARDB_MODEL_MANUALLYSTARTDBCLUSTERREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_MANUALLYSTARTDBCLUSTERREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Polardb { +namespace Model { +class ALIBABACLOUD_POLARDB_EXPORT ManuallyStartDBClusterRequest : public RpcServiceRequest { +public: + ManuallyStartDBClusterRequest(); + ~ManuallyStartDBClusterRequest(); + long getResourceOwnerId() const; + void setResourceOwnerId(long resourceOwnerId); + std::string getAccessKeyId() const; + void setAccessKeyId(const std::string &accessKeyId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getResourceOwnerAccount() const; + void setResourceOwnerAccount(const std::string &resourceOwnerAccount); + std::string getDBClusterId() const; + void setDBClusterId(const std::string &dBClusterId); + std::string getOwnerAccount() const; + void setOwnerAccount(const std::string &ownerAccount); + long getOwnerId() const; + void setOwnerId(long ownerId); + +private: + long resourceOwnerId_; + std::string accessKeyId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string dBClusterId_; + std::string ownerAccount_; + long ownerId_; +}; +} // namespace Model +} // namespace Polardb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_POLARDB_MODEL_MANUALLYSTARTDBCLUSTERREQUEST_H_ diff --git a/polardb/include/alibabacloud/polardb/model/ManuallyStartDBClusterResult.h b/polardb/include/alibabacloud/polardb/model/ManuallyStartDBClusterResult.h new file mode 100644 index 000000000..31daf7866 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/ManuallyStartDBClusterResult.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_POLARDB_MODEL_MANUALLYSTARTDBCLUSTERRESULT_H_ +#define ALIBABACLOUD_POLARDB_MODEL_MANUALLYSTARTDBCLUSTERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Polardb + { + namespace Model + { + class ALIBABACLOUD_POLARDB_EXPORT ManuallyStartDBClusterResult : public ServiceResult + { + public: + + + ManuallyStartDBClusterResult(); + explicit ManuallyStartDBClusterResult(const std::string &payload); + ~ManuallyStartDBClusterResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_POLARDB_MODEL_MANUALLYSTARTDBCLUSTERRESULT_H_ \ No newline at end of file diff --git a/polardb/src/PolardbClient.cc b/polardb/src/PolardbClient.cc index fcca8e156..e9dfd95ae 100644 --- a/polardb/src/PolardbClient.cc +++ b/polardb/src/PolardbClient.cc @@ -159,6 +159,42 @@ PolardbClient::CheckDBNameOutcomeCallable PolardbClient::checkDBNameCallable(con return task->get_future(); } +PolardbClient::CheckKMSAuthorizedOutcome PolardbClient::checkKMSAuthorized(const CheckKMSAuthorizedRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CheckKMSAuthorizedOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CheckKMSAuthorizedOutcome(CheckKMSAuthorizedResult(outcome.result())); + else + return CheckKMSAuthorizedOutcome(outcome.error()); +} + +void PolardbClient::checkKMSAuthorizedAsync(const CheckKMSAuthorizedRequest& request, const CheckKMSAuthorizedAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, checkKMSAuthorized(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +PolardbClient::CheckKMSAuthorizedOutcomeCallable PolardbClient::checkKMSAuthorizedCallable(const CheckKMSAuthorizedRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->checkKMSAuthorized(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + PolardbClient::CloseAITaskOutcome PolardbClient::closeAITask(const CloseAITaskRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1563,6 +1599,42 @@ PolardbClient::DescribeDBClusterAvailableResourcesOutcomeCallable PolardbClient: return task->get_future(); } +PolardbClient::DescribeDBClusterConnectivityOutcome PolardbClient::describeDBClusterConnectivity(const DescribeDBClusterConnectivityRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeDBClusterConnectivityOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeDBClusterConnectivityOutcome(DescribeDBClusterConnectivityResult(outcome.result())); + else + return DescribeDBClusterConnectivityOutcome(outcome.error()); +} + +void PolardbClient::describeDBClusterConnectivityAsync(const DescribeDBClusterConnectivityRequest& request, const DescribeDBClusterConnectivityAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeDBClusterConnectivity(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +PolardbClient::DescribeDBClusterConnectivityOutcomeCallable PolardbClient::describeDBClusterConnectivityCallable(const DescribeDBClusterConnectivityRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeDBClusterConnectivity(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + PolardbClient::DescribeDBClusterEndpointsOutcome PolardbClient::describeDBClusterEndpoints(const DescribeDBClusterEndpointsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2859,6 +2931,42 @@ PolardbClient::DescribeTasksOutcomeCallable PolardbClient::describeTasksCallable return task->get_future(); } +PolardbClient::DescribeUserEncryptionKeyListOutcome PolardbClient::describeUserEncryptionKeyList(const DescribeUserEncryptionKeyListRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeUserEncryptionKeyListOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeUserEncryptionKeyListOutcome(DescribeUserEncryptionKeyListResult(outcome.result())); + else + return DescribeUserEncryptionKeyListOutcome(outcome.error()); +} + +void PolardbClient::describeUserEncryptionKeyListAsync(const DescribeUserEncryptionKeyListRequest& request, const DescribeUserEncryptionKeyListAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeUserEncryptionKeyList(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +PolardbClient::DescribeUserEncryptionKeyListOutcomeCallable PolardbClient::describeUserEncryptionKeyListCallable(const DescribeUserEncryptionKeyListRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeUserEncryptionKeyList(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + PolardbClient::DescribeVSwitchesOutcome PolardbClient::describeVSwitches(const DescribeVSwitchesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -3075,6 +3183,42 @@ PolardbClient::ListTagResourcesOutcomeCallable PolardbClient::listTagResourcesCa return task->get_future(); } +PolardbClient::ManuallyStartDBClusterOutcome PolardbClient::manuallyStartDBCluster(const ManuallyStartDBClusterRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ManuallyStartDBClusterOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ManuallyStartDBClusterOutcome(ManuallyStartDBClusterResult(outcome.result())); + else + return ManuallyStartDBClusterOutcome(outcome.error()); +} + +void PolardbClient::manuallyStartDBClusterAsync(const ManuallyStartDBClusterRequest& request, const ManuallyStartDBClusterAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, manuallyStartDBCluster(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +PolardbClient::ManuallyStartDBClusterOutcomeCallable PolardbClient::manuallyStartDBClusterCallable(const ManuallyStartDBClusterRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->manuallyStartDBCluster(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + PolardbClient::ModifyAccountDescriptionOutcome PolardbClient::modifyAccountDescription(const ModifyAccountDescriptionRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/polardb/src/model/CheckKMSAuthorizedRequest.cc b/polardb/src/model/CheckKMSAuthorizedRequest.cc new file mode 100644 index 000000000..682abd88e --- /dev/null +++ b/polardb/src/model/CheckKMSAuthorizedRequest.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 + +using AlibabaCloud::Polardb::Model::CheckKMSAuthorizedRequest; + +CheckKMSAuthorizedRequest::CheckKMSAuthorizedRequest() + : RpcServiceRequest("polardb", "2017-08-01", "CheckKMSAuthorized") { + setMethod(HttpRequest::Method::Post); +} + +CheckKMSAuthorizedRequest::~CheckKMSAuthorizedRequest() {} + +long CheckKMSAuthorizedRequest::getResourceOwnerId() const { + return resourceOwnerId_; +} + +void CheckKMSAuthorizedRequest::setResourceOwnerId(long resourceOwnerId) { + resourceOwnerId_ = resourceOwnerId; + setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); +} + +std::string CheckKMSAuthorizedRequest::getAccessKeyId() const { + return accessKeyId_; +} + +void CheckKMSAuthorizedRequest::setAccessKeyId(const std::string &accessKeyId) { + accessKeyId_ = accessKeyId; + setParameter(std::string("AccessKeyId"), accessKeyId); +} + +std::string CheckKMSAuthorizedRequest::getRegionId() const { + return regionId_; +} + +void CheckKMSAuthorizedRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string CheckKMSAuthorizedRequest::getResourceOwnerAccount() const { + return resourceOwnerAccount_; +} + +void CheckKMSAuthorizedRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) { + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount); +} + +std::string CheckKMSAuthorizedRequest::getDBClusterId() const { + return dBClusterId_; +} + +void CheckKMSAuthorizedRequest::setDBClusterId(const std::string &dBClusterId) { + dBClusterId_ = dBClusterId; + setParameter(std::string("DBClusterId"), dBClusterId); +} + +std::string CheckKMSAuthorizedRequest::getOwnerAccount() const { + return ownerAccount_; +} + +void CheckKMSAuthorizedRequest::setOwnerAccount(const std::string &ownerAccount) { + ownerAccount_ = ownerAccount; + setParameter(std::string("OwnerAccount"), ownerAccount); +} + +long CheckKMSAuthorizedRequest::getOwnerId() const { + return ownerId_; +} + +void CheckKMSAuthorizedRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + +std::string CheckKMSAuthorizedRequest::getTDERegion() const { + return tDERegion_; +} + +void CheckKMSAuthorizedRequest::setTDERegion(const std::string &tDERegion) { + tDERegion_ = tDERegion; + setParameter(std::string("TDERegion"), tDERegion); +} + diff --git a/polardb/src/model/CheckKMSAuthorizedResult.cc b/polardb/src/model/CheckKMSAuthorizedResult.cc new file mode 100644 index 000000000..c0e5fea29 --- /dev/null +++ b/polardb/src/model/CheckKMSAuthorizedResult.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 +#include + +using namespace AlibabaCloud::Polardb; +using namespace AlibabaCloud::Polardb::Model; + +CheckKMSAuthorizedResult::CheckKMSAuthorizedResult() : + ServiceResult() +{} + +CheckKMSAuthorizedResult::CheckKMSAuthorizedResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CheckKMSAuthorizedResult::~CheckKMSAuthorizedResult() +{} + +void CheckKMSAuthorizedResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["AuthorizationState"].isNull()) + authorizationState_ = std::stoi(value["AuthorizationState"].asString()); + if(!value["RoleArn"].isNull()) + roleArn_ = value["RoleArn"].asString(); + if(!value["DBClusterId"].isNull()) + dBClusterId_ = value["DBClusterId"].asString(); + +} + +int CheckKMSAuthorizedResult::getAuthorizationState()const +{ + return authorizationState_; +} + +std::string CheckKMSAuthorizedResult::getDBClusterId()const +{ + return dBClusterId_; +} + +std::string CheckKMSAuthorizedResult::getRoleArn()const +{ + return roleArn_; +} + diff --git a/polardb/src/model/CreateDBClusterRequest.cc b/polardb/src/model/CreateDBClusterRequest.cc index 4289b87d1..256adea02 100644 --- a/polardb/src/model/CreateDBClusterRequest.cc +++ b/polardb/src/model/CreateDBClusterRequest.cc @@ -345,6 +345,24 @@ void CreateDBClusterRequest::setGDNId(const std::string &gDNId) { setParameter(std::string("GDNId"), gDNId); } +std::string CreateDBClusterRequest::getLooseXEngine() const { + return looseXEngine_; +} + +void CreateDBClusterRequest::setLooseXEngine(const std::string &looseXEngine) { + looseXEngine_ = looseXEngine; + setParameter(std::string("LooseXEngine"), looseXEngine); +} + +std::string CreateDBClusterRequest::getLoosePolarLogBin() const { + return loosePolarLogBin_; +} + +void CreateDBClusterRequest::setLoosePolarLogBin(const std::string &loosePolarLogBin) { + loosePolarLogBin_ = loosePolarLogBin; + setParameter(std::string("LoosePolarLogBin"), loosePolarLogBin); +} + std::string CreateDBClusterRequest::getResourceOwnerAccount() const { return resourceOwnerAccount_; } @@ -363,6 +381,15 @@ void CreateDBClusterRequest::setOwnerAccount(const std::string &ownerAccount) { setParameter(std::string("OwnerAccount"), ownerAccount); } +std::string CreateDBClusterRequest::getLooseXEngineUseMemoryPct() const { + return looseXEngineUseMemoryPct_; +} + +void CreateDBClusterRequest::setLooseXEngineUseMemoryPct(const std::string &looseXEngineUseMemoryPct) { + looseXEngineUseMemoryPct_ = looseXEngineUseMemoryPct; + setParameter(std::string("LooseXEngineUseMemoryPct"), looseXEngineUseMemoryPct); +} + std::string CreateDBClusterRequest::getUsedTime() const { return usedTime_; } diff --git a/polardb/src/model/DescribeDBClusterConnectivityRequest.cc b/polardb/src/model/DescribeDBClusterConnectivityRequest.cc new file mode 100644 index 000000000..f6b3f0613 --- /dev/null +++ b/polardb/src/model/DescribeDBClusterConnectivityRequest.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 + +using AlibabaCloud::Polardb::Model::DescribeDBClusterConnectivityRequest; + +DescribeDBClusterConnectivityRequest::DescribeDBClusterConnectivityRequest() + : RpcServiceRequest("polardb", "2017-08-01", "DescribeDBClusterConnectivity") { + setMethod(HttpRequest::Method::Post); +} + +DescribeDBClusterConnectivityRequest::~DescribeDBClusterConnectivityRequest() {} + +long DescribeDBClusterConnectivityRequest::getResourceOwnerId() const { + return resourceOwnerId_; +} + +void DescribeDBClusterConnectivityRequest::setResourceOwnerId(long resourceOwnerId) { + resourceOwnerId_ = resourceOwnerId; + setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); +} + +std::string DescribeDBClusterConnectivityRequest::getAccessKeyId() const { + return accessKeyId_; +} + +void DescribeDBClusterConnectivityRequest::setAccessKeyId(const std::string &accessKeyId) { + accessKeyId_ = accessKeyId; + setParameter(std::string("AccessKeyId"), accessKeyId); +} + +std::string DescribeDBClusterConnectivityRequest::getResourceGroupId() const { + return resourceGroupId_; +} + +void DescribeDBClusterConnectivityRequest::setResourceGroupId(const std::string &resourceGroupId) { + resourceGroupId_ = resourceGroupId; + setParameter(std::string("ResourceGroupId"), resourceGroupId); +} + +std::string DescribeDBClusterConnectivityRequest::getSecurityToken() const { + return securityToken_; +} + +void DescribeDBClusterConnectivityRequest::setSecurityToken(const std::string &securityToken) { + securityToken_ = securityToken; + setParameter(std::string("SecurityToken"), securityToken); +} + +std::string DescribeDBClusterConnectivityRequest::getSourceIpAddress() const { + return sourceIpAddress_; +} + +void DescribeDBClusterConnectivityRequest::setSourceIpAddress(const std::string &sourceIpAddress) { + sourceIpAddress_ = sourceIpAddress; + setParameter(std::string("SourceIpAddress"), sourceIpAddress); +} + +std::string DescribeDBClusterConnectivityRequest::getResourceOwnerAccount() const { + return resourceOwnerAccount_; +} + +void DescribeDBClusterConnectivityRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) { + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount); +} + +std::string DescribeDBClusterConnectivityRequest::getDBClusterId() const { + return dBClusterId_; +} + +void DescribeDBClusterConnectivityRequest::setDBClusterId(const std::string &dBClusterId) { + dBClusterId_ = dBClusterId; + setParameter(std::string("DBClusterId"), dBClusterId); +} + +std::string DescribeDBClusterConnectivityRequest::getOwnerAccount() const { + return ownerAccount_; +} + +void DescribeDBClusterConnectivityRequest::setOwnerAccount(const std::string &ownerAccount) { + ownerAccount_ = ownerAccount; + setParameter(std::string("OwnerAccount"), ownerAccount); +} + +long DescribeDBClusterConnectivityRequest::getOwnerId() const { + return ownerId_; +} + +void DescribeDBClusterConnectivityRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + diff --git a/polardb/src/model/DescribeDBClusterConnectivityResult.cc b/polardb/src/model/DescribeDBClusterConnectivityResult.cc new file mode 100644 index 000000000..41e68f8b9 --- /dev/null +++ b/polardb/src/model/DescribeDBClusterConnectivityResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Polardb; +using namespace AlibabaCloud::Polardb::Model; + +DescribeDBClusterConnectivityResult::DescribeDBClusterConnectivityResult() : + ServiceResult() +{} + +DescribeDBClusterConnectivityResult::DescribeDBClusterConnectivityResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeDBClusterConnectivityResult::~DescribeDBClusterConnectivityResult() +{} + +void DescribeDBClusterConnectivityResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["DBClusterId"].isNull()) + dBClusterId_ = value["DBClusterId"].asString(); + if(!value["ConnCheckResult"].isNull()) + connCheckResult_ = value["ConnCheckResult"].asString(); + if(!value["ConnCheckErrorCode"].isNull()) + connCheckErrorCode_ = value["ConnCheckErrorCode"].asString(); + if(!value["ConnCheckErrorMessage"].isNull()) + connCheckErrorMessage_ = value["ConnCheckErrorMessage"].asString(); + +} + +std::string DescribeDBClusterConnectivityResult::getConnCheckErrorCode()const +{ + return connCheckErrorCode_; +} + +std::string DescribeDBClusterConnectivityResult::getConnCheckResult()const +{ + return connCheckResult_; +} + +std::string DescribeDBClusterConnectivityResult::getConnCheckErrorMessage()const +{ + return connCheckErrorMessage_; +} + +std::string DescribeDBClusterConnectivityResult::getDBClusterId()const +{ + return dBClusterId_; +} + diff --git a/polardb/src/model/DescribeUserEncryptionKeyListRequest.cc b/polardb/src/model/DescribeUserEncryptionKeyListRequest.cc new file mode 100644 index 000000000..79d31a3e2 --- /dev/null +++ b/polardb/src/model/DescribeUserEncryptionKeyListRequest.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 + +using AlibabaCloud::Polardb::Model::DescribeUserEncryptionKeyListRequest; + +DescribeUserEncryptionKeyListRequest::DescribeUserEncryptionKeyListRequest() + : RpcServiceRequest("polardb", "2017-08-01", "DescribeUserEncryptionKeyList") { + setMethod(HttpRequest::Method::Post); +} + +DescribeUserEncryptionKeyListRequest::~DescribeUserEncryptionKeyListRequest() {} + +long DescribeUserEncryptionKeyListRequest::getResourceOwnerId() const { + return resourceOwnerId_; +} + +void DescribeUserEncryptionKeyListRequest::setResourceOwnerId(long resourceOwnerId) { + resourceOwnerId_ = resourceOwnerId; + setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); +} + +std::string DescribeUserEncryptionKeyListRequest::getAccessKeyId() const { + return accessKeyId_; +} + +void DescribeUserEncryptionKeyListRequest::setAccessKeyId(const std::string &accessKeyId) { + accessKeyId_ = accessKeyId; + setParameter(std::string("AccessKeyId"), accessKeyId); +} + +std::string DescribeUserEncryptionKeyListRequest::getRegionId() const { + return regionId_; +} + +void DescribeUserEncryptionKeyListRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string DescribeUserEncryptionKeyListRequest::getResourceOwnerAccount() const { + return resourceOwnerAccount_; +} + +void DescribeUserEncryptionKeyListRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) { + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount); +} + +std::string DescribeUserEncryptionKeyListRequest::getDBClusterId() const { + return dBClusterId_; +} + +void DescribeUserEncryptionKeyListRequest::setDBClusterId(const std::string &dBClusterId) { + dBClusterId_ = dBClusterId; + setParameter(std::string("DBClusterId"), dBClusterId); +} + +std::string DescribeUserEncryptionKeyListRequest::getOwnerAccount() const { + return ownerAccount_; +} + +void DescribeUserEncryptionKeyListRequest::setOwnerAccount(const std::string &ownerAccount) { + ownerAccount_ = ownerAccount; + setParameter(std::string("OwnerAccount"), ownerAccount); +} + +long DescribeUserEncryptionKeyListRequest::getOwnerId() const { + return ownerId_; +} + +void DescribeUserEncryptionKeyListRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + +std::string DescribeUserEncryptionKeyListRequest::getTDERegion() const { + return tDERegion_; +} + +void DescribeUserEncryptionKeyListRequest::setTDERegion(const std::string &tDERegion) { + tDERegion_ = tDERegion; + setParameter(std::string("TDERegion"), tDERegion); +} + diff --git a/polardb/src/model/DescribeUserEncryptionKeyListResult.cc b/polardb/src/model/DescribeUserEncryptionKeyListResult.cc new file mode 100644 index 000000000..c3bd3091d --- /dev/null +++ b/polardb/src/model/DescribeUserEncryptionKeyListResult.cc @@ -0,0 +1,59 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Polardb; +using namespace AlibabaCloud::Polardb::Model; + +DescribeUserEncryptionKeyListResult::DescribeUserEncryptionKeyListResult() : + ServiceResult() +{} + +DescribeUserEncryptionKeyListResult::DescribeUserEncryptionKeyListResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeUserEncryptionKeyListResult::~DescribeUserEncryptionKeyListResult() +{} + +void DescribeUserEncryptionKeyListResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allKeyList = value["KeyList"]["Key"]; + for (const auto &item : allKeyList) + keyList_.push_back(item.asString()); + if(!value["DBClusterId"].isNull()) + dBClusterId_ = value["DBClusterId"].asString(); + +} + +std::vector DescribeUserEncryptionKeyListResult::getKeyList()const +{ + return keyList_; +} + +std::string DescribeUserEncryptionKeyListResult::getDBClusterId()const +{ + return dBClusterId_; +} + diff --git a/polardb/src/model/ManuallyStartDBClusterRequest.cc b/polardb/src/model/ManuallyStartDBClusterRequest.cc new file mode 100644 index 000000000..272ee9aef --- /dev/null +++ b/polardb/src/model/ManuallyStartDBClusterRequest.cc @@ -0,0 +1,90 @@ +/* + * 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 + +using AlibabaCloud::Polardb::Model::ManuallyStartDBClusterRequest; + +ManuallyStartDBClusterRequest::ManuallyStartDBClusterRequest() + : RpcServiceRequest("polardb", "2017-08-01", "ManuallyStartDBCluster") { + setMethod(HttpRequest::Method::Post); +} + +ManuallyStartDBClusterRequest::~ManuallyStartDBClusterRequest() {} + +long ManuallyStartDBClusterRequest::getResourceOwnerId() const { + return resourceOwnerId_; +} + +void ManuallyStartDBClusterRequest::setResourceOwnerId(long resourceOwnerId) { + resourceOwnerId_ = resourceOwnerId; + setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); +} + +std::string ManuallyStartDBClusterRequest::getAccessKeyId() const { + return accessKeyId_; +} + +void ManuallyStartDBClusterRequest::setAccessKeyId(const std::string &accessKeyId) { + accessKeyId_ = accessKeyId; + setParameter(std::string("AccessKeyId"), accessKeyId); +} + +std::string ManuallyStartDBClusterRequest::getRegionId() const { + return regionId_; +} + +void ManuallyStartDBClusterRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string ManuallyStartDBClusterRequest::getResourceOwnerAccount() const { + return resourceOwnerAccount_; +} + +void ManuallyStartDBClusterRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) { + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount); +} + +std::string ManuallyStartDBClusterRequest::getDBClusterId() const { + return dBClusterId_; +} + +void ManuallyStartDBClusterRequest::setDBClusterId(const std::string &dBClusterId) { + dBClusterId_ = dBClusterId; + setParameter(std::string("DBClusterId"), dBClusterId); +} + +std::string ManuallyStartDBClusterRequest::getOwnerAccount() const { + return ownerAccount_; +} + +void ManuallyStartDBClusterRequest::setOwnerAccount(const std::string &ownerAccount) { + ownerAccount_ = ownerAccount; + setParameter(std::string("OwnerAccount"), ownerAccount); +} + +long ManuallyStartDBClusterRequest::getOwnerId() const { + return ownerId_; +} + +void ManuallyStartDBClusterRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + diff --git a/polardb/src/model/ManuallyStartDBClusterResult.cc b/polardb/src/model/ManuallyStartDBClusterResult.cc new file mode 100644 index 000000000..a56b30713 --- /dev/null +++ b/polardb/src/model/ManuallyStartDBClusterResult.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 +#include + +using namespace AlibabaCloud::Polardb; +using namespace AlibabaCloud::Polardb::Model; + +ManuallyStartDBClusterResult::ManuallyStartDBClusterResult() : + ServiceResult() +{} + +ManuallyStartDBClusterResult::ManuallyStartDBClusterResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ManuallyStartDBClusterResult::~ManuallyStartDBClusterResult() +{} + +void ManuallyStartDBClusterResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} +