From 8137298eb1735ee2f82748fd92ac4643f755e3fa Mon Sep 17 00:00:00 2001 From: sdk-team Date: Fri, 7 Jan 2022 13:25:21 +0000 Subject: [PATCH] Support resource scheduler. --- CHANGELOG | 3 + VERSION | 2 +- privatelink/CMakeLists.txt | 20 ++- .../privatelink/PrivatelinkClient.h | 32 ++++ ...ttachResourceToVpcEndpointServiceRequest.h | 3 + .../model/CreateVpcEndpointServiceRequest.h | 1 + ...achResourceFromVpcEndpointServiceRequest.h | 3 + .../DisableVpcEndpointZoneConnectionRequest.h | 60 ++++++++ .../DisableVpcEndpointZoneConnectionResult.h | 49 ++++++ .../EnableVpcEndpointZoneConnectionRequest.h | 57 +++++++ .../EnableVpcEndpointZoneConnectionResult.h | 49 ++++++ .../model/ListVpcEndpointConnectionsRequest.h | 3 + ...cEndpointServiceResourceAttributeRequest.h | 63 ++++++++ ...pcEndpointServiceResourceAttributeResult.h | 49 ++++++ ...ntZoneConnectionResourceAttributeRequest.h | 69 +++++++++ ...intZoneConnectionResourceAttributeResult.h | 49 ++++++ privatelink/src/PrivatelinkClient.cc | 144 ++++++++++++++++++ ...tachResourceToVpcEndpointServiceRequest.cc | 9 ++ .../model/CreateVpcEndpointServiceRequest.cc | 1 + ...chResourceFromVpcEndpointServiceRequest.cc | 9 ++ ...DisableVpcEndpointZoneConnectionRequest.cc | 90 +++++++++++ .../DisableVpcEndpointZoneConnectionResult.cc | 44 ++++++ .../EnableVpcEndpointZoneConnectionRequest.cc | 81 ++++++++++ .../EnableVpcEndpointZoneConnectionResult.cc | 44 ++++++ .../ListVpcEndpointConnectionsRequest.cc | 9 ++ ...EndpointServiceResourceAttributeRequest.cc | 99 ++++++++++++ ...cEndpointServiceResourceAttributeResult.cc | 44 ++++++ ...tZoneConnectionResourceAttributeRequest.cc | 117 ++++++++++++++ ...ntZoneConnectionResourceAttributeResult.cc | 44 ++++++ 29 files changed, 1244 insertions(+), 3 deletions(-) create mode 100644 privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionRequest.h create mode 100644 privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionResult.h create mode 100644 privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionRequest.h create mode 100644 privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionResult.h create mode 100644 privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeRequest.h create mode 100644 privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeResult.h create mode 100644 privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.h create mode 100644 privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.h create mode 100644 privatelink/src/model/DisableVpcEndpointZoneConnectionRequest.cc create mode 100644 privatelink/src/model/DisableVpcEndpointZoneConnectionResult.cc create mode 100644 privatelink/src/model/EnableVpcEndpointZoneConnectionRequest.cc create mode 100644 privatelink/src/model/EnableVpcEndpointZoneConnectionResult.cc create mode 100644 privatelink/src/model/UpdateVpcEndpointServiceResourceAttributeRequest.cc create mode 100644 privatelink/src/model/UpdateVpcEndpointServiceResourceAttributeResult.cc create mode 100644 privatelink/src/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.cc create mode 100644 privatelink/src/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.cc diff --git a/CHANGELOG b/CHANGELOG index 25d224fd7..7debf5304 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2022-01-07 Version: 1.36.1019 +- Support resource scheduler. + 2022-01-07 Version: 1.36.1018 - Add or modify APIs, include, QueryEmbeddedStaus, QueryWorks, QueryWorksByWorkspace. diff --git a/VERSION b/VERSION index 9a3b0a0c1..f5743907d 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1018 \ No newline at end of file +1.36.1019 \ No newline at end of file diff --git a/privatelink/CMakeLists.txt b/privatelink/CMakeLists.txt index 3aa43efb3..1e1685897 100644 --- a/privatelink/CMakeLists.txt +++ b/privatelink/CMakeLists.txt @@ -49,8 +49,12 @@ set(privatelink_public_header_model include/alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointResult.h include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionRequest.h include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionResult.h + include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionRequest.h + include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionResult.h include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionRequest.h include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionResult.h + include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionRequest.h + include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionResult.h include/alibabacloud/privatelink/model/GetVpcEndpointAttributeRequest.h include/alibabacloud/privatelink/model/GetVpcEndpointAttributeResult.h include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeRequest.h @@ -82,7 +86,11 @@ set(privatelink_public_header_model include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeRequest.h include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeResult.h include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeRequest.h - include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeResult.h ) + include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeResult.h + include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeRequest.h + include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeResult.h + include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.h + include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.h ) set(privatelink_src src/PrivatelinkClient.cc @@ -114,8 +122,12 @@ set(privatelink_src src/model/DetachSecurityGroupFromVpcEndpointResult.cc src/model/DisableVpcEndpointConnectionRequest.cc src/model/DisableVpcEndpointConnectionResult.cc + src/model/DisableVpcEndpointZoneConnectionRequest.cc + src/model/DisableVpcEndpointZoneConnectionResult.cc src/model/EnableVpcEndpointConnectionRequest.cc src/model/EnableVpcEndpointConnectionResult.cc + src/model/EnableVpcEndpointZoneConnectionRequest.cc + src/model/EnableVpcEndpointZoneConnectionResult.cc src/model/GetVpcEndpointAttributeRequest.cc src/model/GetVpcEndpointAttributeResult.cc src/model/GetVpcEndpointServiceAttributeRequest.cc @@ -147,7 +159,11 @@ set(privatelink_src src/model/UpdateVpcEndpointConnectionAttributeRequest.cc src/model/UpdateVpcEndpointConnectionAttributeResult.cc src/model/UpdateVpcEndpointServiceAttributeRequest.cc - src/model/UpdateVpcEndpointServiceAttributeResult.cc ) + src/model/UpdateVpcEndpointServiceAttributeResult.cc + src/model/UpdateVpcEndpointServiceResourceAttributeRequest.cc + src/model/UpdateVpcEndpointServiceResourceAttributeResult.cc + src/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.cc + src/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.cc ) add_library(privatelink ${LIB_TYPE} ${privatelink_public_header} diff --git a/privatelink/include/alibabacloud/privatelink/PrivatelinkClient.h b/privatelink/include/alibabacloud/privatelink/PrivatelinkClient.h index a4db36579..593735961 100644 --- a/privatelink/include/alibabacloud/privatelink/PrivatelinkClient.h +++ b/privatelink/include/alibabacloud/privatelink/PrivatelinkClient.h @@ -50,8 +50,12 @@ #include "model/DetachSecurityGroupFromVpcEndpointResult.h" #include "model/DisableVpcEndpointConnectionRequest.h" #include "model/DisableVpcEndpointConnectionResult.h" +#include "model/DisableVpcEndpointZoneConnectionRequest.h" +#include "model/DisableVpcEndpointZoneConnectionResult.h" #include "model/EnableVpcEndpointConnectionRequest.h" #include "model/EnableVpcEndpointConnectionResult.h" +#include "model/EnableVpcEndpointZoneConnectionRequest.h" +#include "model/EnableVpcEndpointZoneConnectionResult.h" #include "model/GetVpcEndpointAttributeRequest.h" #include "model/GetVpcEndpointAttributeResult.h" #include "model/GetVpcEndpointServiceAttributeRequest.h" @@ -84,6 +88,10 @@ #include "model/UpdateVpcEndpointConnectionAttributeResult.h" #include "model/UpdateVpcEndpointServiceAttributeRequest.h" #include "model/UpdateVpcEndpointServiceAttributeResult.h" +#include "model/UpdateVpcEndpointServiceResourceAttributeRequest.h" +#include "model/UpdateVpcEndpointServiceResourceAttributeResult.h" +#include "model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.h" +#include "model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.h" namespace AlibabaCloud @@ -135,9 +143,15 @@ namespace AlibabaCloud typedef Outcome DisableVpcEndpointConnectionOutcome; typedef std::future DisableVpcEndpointConnectionOutcomeCallable; typedef std::function&)> DisableVpcEndpointConnectionAsyncHandler; + typedef Outcome DisableVpcEndpointZoneConnectionOutcome; + typedef std::future DisableVpcEndpointZoneConnectionOutcomeCallable; + typedef std::function&)> DisableVpcEndpointZoneConnectionAsyncHandler; typedef Outcome EnableVpcEndpointConnectionOutcome; typedef std::future EnableVpcEndpointConnectionOutcomeCallable; typedef std::function&)> EnableVpcEndpointConnectionAsyncHandler; + typedef Outcome EnableVpcEndpointZoneConnectionOutcome; + typedef std::future EnableVpcEndpointZoneConnectionOutcomeCallable; + typedef std::function&)> EnableVpcEndpointZoneConnectionAsyncHandler; typedef Outcome GetVpcEndpointAttributeOutcome; typedef std::future GetVpcEndpointAttributeOutcomeCallable; typedef std::function&)> GetVpcEndpointAttributeAsyncHandler; @@ -186,6 +200,12 @@ namespace AlibabaCloud typedef Outcome UpdateVpcEndpointServiceAttributeOutcome; typedef std::future UpdateVpcEndpointServiceAttributeOutcomeCallable; typedef std::function&)> UpdateVpcEndpointServiceAttributeAsyncHandler; + typedef Outcome UpdateVpcEndpointServiceResourceAttributeOutcome; + typedef std::future UpdateVpcEndpointServiceResourceAttributeOutcomeCallable; + typedef std::function&)> UpdateVpcEndpointServiceResourceAttributeAsyncHandler; + typedef Outcome UpdateVpcEndpointZoneConnectionResourceAttributeOutcome; + typedef std::future UpdateVpcEndpointZoneConnectionResourceAttributeOutcomeCallable; + typedef std::function&)> UpdateVpcEndpointZoneConnectionResourceAttributeAsyncHandler; PrivatelinkClient(const Credentials &credentials, const ClientConfiguration &configuration); PrivatelinkClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); @@ -233,9 +253,15 @@ namespace AlibabaCloud DisableVpcEndpointConnectionOutcome disableVpcEndpointConnection(const Model::DisableVpcEndpointConnectionRequest &request)const; void disableVpcEndpointConnectionAsync(const Model::DisableVpcEndpointConnectionRequest& request, const DisableVpcEndpointConnectionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DisableVpcEndpointConnectionOutcomeCallable disableVpcEndpointConnectionCallable(const Model::DisableVpcEndpointConnectionRequest& request) const; + DisableVpcEndpointZoneConnectionOutcome disableVpcEndpointZoneConnection(const Model::DisableVpcEndpointZoneConnectionRequest &request)const; + void disableVpcEndpointZoneConnectionAsync(const Model::DisableVpcEndpointZoneConnectionRequest& request, const DisableVpcEndpointZoneConnectionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DisableVpcEndpointZoneConnectionOutcomeCallable disableVpcEndpointZoneConnectionCallable(const Model::DisableVpcEndpointZoneConnectionRequest& request) const; EnableVpcEndpointConnectionOutcome enableVpcEndpointConnection(const Model::EnableVpcEndpointConnectionRequest &request)const; void enableVpcEndpointConnectionAsync(const Model::EnableVpcEndpointConnectionRequest& request, const EnableVpcEndpointConnectionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; EnableVpcEndpointConnectionOutcomeCallable enableVpcEndpointConnectionCallable(const Model::EnableVpcEndpointConnectionRequest& request) const; + EnableVpcEndpointZoneConnectionOutcome enableVpcEndpointZoneConnection(const Model::EnableVpcEndpointZoneConnectionRequest &request)const; + void enableVpcEndpointZoneConnectionAsync(const Model::EnableVpcEndpointZoneConnectionRequest& request, const EnableVpcEndpointZoneConnectionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + EnableVpcEndpointZoneConnectionOutcomeCallable enableVpcEndpointZoneConnectionCallable(const Model::EnableVpcEndpointZoneConnectionRequest& request) const; GetVpcEndpointAttributeOutcome getVpcEndpointAttribute(const Model::GetVpcEndpointAttributeRequest &request)const; void getVpcEndpointAttributeAsync(const Model::GetVpcEndpointAttributeRequest& request, const GetVpcEndpointAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetVpcEndpointAttributeOutcomeCallable getVpcEndpointAttributeCallable(const Model::GetVpcEndpointAttributeRequest& request) const; @@ -284,6 +310,12 @@ namespace AlibabaCloud UpdateVpcEndpointServiceAttributeOutcome updateVpcEndpointServiceAttribute(const Model::UpdateVpcEndpointServiceAttributeRequest &request)const; void updateVpcEndpointServiceAttributeAsync(const Model::UpdateVpcEndpointServiceAttributeRequest& request, const UpdateVpcEndpointServiceAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateVpcEndpointServiceAttributeOutcomeCallable updateVpcEndpointServiceAttributeCallable(const Model::UpdateVpcEndpointServiceAttributeRequest& request) const; + UpdateVpcEndpointServiceResourceAttributeOutcome updateVpcEndpointServiceResourceAttribute(const Model::UpdateVpcEndpointServiceResourceAttributeRequest &request)const; + void updateVpcEndpointServiceResourceAttributeAsync(const Model::UpdateVpcEndpointServiceResourceAttributeRequest& request, const UpdateVpcEndpointServiceResourceAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateVpcEndpointServiceResourceAttributeOutcomeCallable updateVpcEndpointServiceResourceAttributeCallable(const Model::UpdateVpcEndpointServiceResourceAttributeRequest& request) const; + UpdateVpcEndpointZoneConnectionResourceAttributeOutcome updateVpcEndpointZoneConnectionResourceAttribute(const Model::UpdateVpcEndpointZoneConnectionResourceAttributeRequest &request)const; + void updateVpcEndpointZoneConnectionResourceAttributeAsync(const Model::UpdateVpcEndpointZoneConnectionResourceAttributeRequest& request, const UpdateVpcEndpointZoneConnectionResourceAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateVpcEndpointZoneConnectionResourceAttributeOutcomeCallable updateVpcEndpointZoneConnectionResourceAttributeCallable(const Model::UpdateVpcEndpointZoneConnectionResourceAttributeRequest& request) const; private: std::shared_ptr endpointProvider_; diff --git a/privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h b/privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h index 227e99cce..51779a941 100644 --- a/privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h +++ b/privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h @@ -40,6 +40,8 @@ public: void setDryRun(bool dryRun); std::string getResourceType() const; void setResourceType(const std::string &resourceType); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); std::string getServiceId() const; void setServiceId(const std::string &serviceId); @@ -49,6 +51,7 @@ private: std::string resourceId_; bool dryRun_; std::string resourceType_; + std::string zoneId_; std::string serviceId_; }; } // namespace Model diff --git a/privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h b/privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h index 177436662..fdbe925cd 100644 --- a/privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h +++ b/privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h @@ -31,6 +31,7 @@ public: struct Resource { std::string resourceType; std::string resourceId; + std::string zoneId; }; CreateVpcEndpointServiceRequest(); ~CreateVpcEndpointServiceRequest(); diff --git a/privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h b/privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h index b10f4e101..0a26e871b 100644 --- a/privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h +++ b/privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h @@ -40,6 +40,8 @@ public: void setDryRun(bool dryRun); std::string getResourceType() const; void setResourceType(const std::string &resourceType); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); std::string getServiceId() const; void setServiceId(const std::string &serviceId); @@ -49,6 +51,7 @@ private: std::string resourceId_; bool dryRun_; std::string resourceType_; + std::string zoneId_; std::string serviceId_; }; } // namespace Model diff --git a/privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionRequest.h b/privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionRequest.h new file mode 100644 index 000000000..1802c96bc --- /dev/null +++ b/privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionRequest.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_PRIVATELINK_MODEL_DISABLEVPCENDPOINTZONECONNECTIONREQUEST_H_ +#define ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTZONECONNECTIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Privatelink { +namespace Model { +class ALIBABACLOUD_PRIVATELINK_EXPORT DisableVpcEndpointZoneConnectionRequest : public RpcServiceRequest { +public: + DisableVpcEndpointZoneConnectionRequest(); + ~DisableVpcEndpointZoneConnectionRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getEndpointId() const; + void setEndpointId(const std::string &endpointId); + bool getReplacedResource() const; + void setReplacedResource(bool replacedResource); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); + std::string getServiceId() const; + void setServiceId(const std::string &serviceId); + +private: + std::string clientToken_; + std::string endpointId_; + bool replacedResource_; + std::string regionId_; + bool dryRun_; + std::string zoneId_; + std::string serviceId_; +}; +} // namespace Model +} // namespace Privatelink +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTZONECONNECTIONREQUEST_H_ diff --git a/privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionResult.h b/privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionResult.h new file mode 100644 index 000000000..0c3fb4b4a --- /dev/null +++ b/privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointZoneConnectionResult.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_PRIVATELINK_MODEL_DISABLEVPCENDPOINTZONECONNECTIONRESULT_H_ +#define ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTZONECONNECTIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Privatelink + { + namespace Model + { + class ALIBABACLOUD_PRIVATELINK_EXPORT DisableVpcEndpointZoneConnectionResult : public ServiceResult + { + public: + + + DisableVpcEndpointZoneConnectionResult(); + explicit DisableVpcEndpointZoneConnectionResult(const std::string &payload); + ~DisableVpcEndpointZoneConnectionResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTZONECONNECTIONRESULT_H_ \ No newline at end of file diff --git a/privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionRequest.h b/privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionRequest.h new file mode 100644 index 000000000..875734ee8 --- /dev/null +++ b/privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionRequest.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_PRIVATELINK_MODEL_ENABLEVPCENDPOINTZONECONNECTIONREQUEST_H_ +#define ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTZONECONNECTIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Privatelink { +namespace Model { +class ALIBABACLOUD_PRIVATELINK_EXPORT EnableVpcEndpointZoneConnectionRequest : public RpcServiceRequest { +public: + EnableVpcEndpointZoneConnectionRequest(); + ~EnableVpcEndpointZoneConnectionRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getEndpointId() const; + void setEndpointId(const std::string &endpointId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); + std::string getServiceId() const; + void setServiceId(const std::string &serviceId); + +private: + std::string clientToken_; + std::string endpointId_; + std::string regionId_; + bool dryRun_; + std::string zoneId_; + std::string serviceId_; +}; +} // namespace Model +} // namespace Privatelink +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTZONECONNECTIONREQUEST_H_ diff --git a/privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionResult.h b/privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionResult.h new file mode 100644 index 000000000..5448ee707 --- /dev/null +++ b/privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointZoneConnectionResult.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_PRIVATELINK_MODEL_ENABLEVPCENDPOINTZONECONNECTIONRESULT_H_ +#define ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTZONECONNECTIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Privatelink + { + namespace Model + { + class ALIBABACLOUD_PRIVATELINK_EXPORT EnableVpcEndpointZoneConnectionResult : public ServiceResult + { + public: + + + EnableVpcEndpointZoneConnectionResult(); + explicit EnableVpcEndpointZoneConnectionResult(const std::string &payload); + ~EnableVpcEndpointZoneConnectionResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTZONECONNECTIONRESULT_H_ \ No newline at end of file diff --git a/privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h b/privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h index 733f09383..8c07dfde0 100644 --- a/privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h +++ b/privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h @@ -48,6 +48,8 @@ public: void setMaxResults(int maxResults); std::string getEniId() const; void setEniId(const std::string &eniId); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); std::string getServiceId() const; void setServiceId(const std::string &serviceId); @@ -61,6 +63,7 @@ private: std::string connectionStatus_; int maxResults_; std::string eniId_; + std::string zoneId_; std::string serviceId_; }; } // namespace Model diff --git a/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeRequest.h b/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeRequest.h new file mode 100644 index 000000000..df41a5461 --- /dev/null +++ b/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeRequest.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICERESOURCEATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICERESOURCEATTRIBUTEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Privatelink { +namespace Model { +class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointServiceResourceAttributeRequest : public RpcServiceRequest { +public: + UpdateVpcEndpointServiceResourceAttributeRequest(); + ~UpdateVpcEndpointServiceResourceAttributeRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + bool getAutoAllocatedEnabled() const; + void setAutoAllocatedEnabled(bool autoAllocatedEnabled); + std::string getResourceId() const; + void setResourceId(const std::string &resourceId); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::string getResourceType() const; + void setResourceType(const std::string &resourceType); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); + std::string getServiceId() const; + void setServiceId(const std::string &serviceId); + +private: + std::string clientToken_; + std::string regionId_; + bool autoAllocatedEnabled_; + std::string resourceId_; + bool dryRun_; + std::string resourceType_; + std::string zoneId_; + std::string serviceId_; +}; +} // namespace Model +} // namespace Privatelink +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICERESOURCEATTRIBUTEREQUEST_H_ diff --git a/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeResult.h b/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeResult.h new file mode 100644 index 000000000..7f63d5caf --- /dev/null +++ b/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceResourceAttributeResult.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICERESOURCEATTRIBUTERESULT_H_ +#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICERESOURCEATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Privatelink + { + namespace Model + { + class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointServiceResourceAttributeResult : public ServiceResult + { + public: + + + UpdateVpcEndpointServiceResourceAttributeResult(); + explicit UpdateVpcEndpointServiceResourceAttributeResult(const std::string &payload); + ~UpdateVpcEndpointServiceResourceAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICERESOURCEATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.h b/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.h new file mode 100644 index 000000000..e8bb6ab25 --- /dev/null +++ b/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.h @@ -0,0 +1,69 @@ +/* + * 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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTZONECONNECTIONRESOURCEATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTZONECONNECTIONRESOURCEATTRIBUTEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Privatelink { +namespace Model { +class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointZoneConnectionResourceAttributeRequest : public RpcServiceRequest { +public: + UpdateVpcEndpointZoneConnectionResourceAttributeRequest(); + ~UpdateVpcEndpointZoneConnectionResourceAttributeRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getEndpointId() const; + void setEndpointId(const std::string &endpointId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getResourceId() const; + void setResourceId(const std::string &resourceId); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::string getResourceAllocateMode() const; + void setResourceAllocateMode(const std::string &resourceAllocateMode); + std::string getResourceType() const; + void setResourceType(const std::string &resourceType); + std::string getResourceReplaceMode() const; + void setResourceReplaceMode(const std::string &resourceReplaceMode); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); + std::string getServiceId() const; + void setServiceId(const std::string &serviceId); + +private: + std::string clientToken_; + std::string endpointId_; + std::string regionId_; + std::string resourceId_; + bool dryRun_; + std::string resourceAllocateMode_; + std::string resourceType_; + std::string resourceReplaceMode_; + std::string zoneId_; + std::string serviceId_; +}; +} // namespace Model +} // namespace Privatelink +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTZONECONNECTIONRESOURCEATTRIBUTEREQUEST_H_ diff --git a/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.h b/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.h new file mode 100644 index 000000000..5997e5e46 --- /dev/null +++ b/privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTZONECONNECTIONRESOURCEATTRIBUTERESULT_H_ +#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTZONECONNECTIONRESOURCEATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Privatelink + { + namespace Model + { + class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointZoneConnectionResourceAttributeResult : public ServiceResult + { + public: + + + UpdateVpcEndpointZoneConnectionResourceAttributeResult(); + explicit UpdateVpcEndpointZoneConnectionResourceAttributeResult(const std::string &payload); + ~UpdateVpcEndpointZoneConnectionResourceAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTZONECONNECTIONRESOURCEATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/privatelink/src/PrivatelinkClient.cc b/privatelink/src/PrivatelinkClient.cc index 77276ffb9..23644edd8 100644 --- a/privatelink/src/PrivatelinkClient.cc +++ b/privatelink/src/PrivatelinkClient.cc @@ -555,6 +555,42 @@ PrivatelinkClient::DisableVpcEndpointConnectionOutcomeCallable PrivatelinkClient return task->get_future(); } +PrivatelinkClient::DisableVpcEndpointZoneConnectionOutcome PrivatelinkClient::disableVpcEndpointZoneConnection(const DisableVpcEndpointZoneConnectionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DisableVpcEndpointZoneConnectionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DisableVpcEndpointZoneConnectionOutcome(DisableVpcEndpointZoneConnectionResult(outcome.result())); + else + return DisableVpcEndpointZoneConnectionOutcome(outcome.error()); +} + +void PrivatelinkClient::disableVpcEndpointZoneConnectionAsync(const DisableVpcEndpointZoneConnectionRequest& request, const DisableVpcEndpointZoneConnectionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, disableVpcEndpointZoneConnection(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +PrivatelinkClient::DisableVpcEndpointZoneConnectionOutcomeCallable PrivatelinkClient::disableVpcEndpointZoneConnectionCallable(const DisableVpcEndpointZoneConnectionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->disableVpcEndpointZoneConnection(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + PrivatelinkClient::EnableVpcEndpointConnectionOutcome PrivatelinkClient::enableVpcEndpointConnection(const EnableVpcEndpointConnectionRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -591,6 +627,42 @@ PrivatelinkClient::EnableVpcEndpointConnectionOutcomeCallable PrivatelinkClient: return task->get_future(); } +PrivatelinkClient::EnableVpcEndpointZoneConnectionOutcome PrivatelinkClient::enableVpcEndpointZoneConnection(const EnableVpcEndpointZoneConnectionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return EnableVpcEndpointZoneConnectionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return EnableVpcEndpointZoneConnectionOutcome(EnableVpcEndpointZoneConnectionResult(outcome.result())); + else + return EnableVpcEndpointZoneConnectionOutcome(outcome.error()); +} + +void PrivatelinkClient::enableVpcEndpointZoneConnectionAsync(const EnableVpcEndpointZoneConnectionRequest& request, const EnableVpcEndpointZoneConnectionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, enableVpcEndpointZoneConnection(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +PrivatelinkClient::EnableVpcEndpointZoneConnectionOutcomeCallable PrivatelinkClient::enableVpcEndpointZoneConnectionCallable(const EnableVpcEndpointZoneConnectionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->enableVpcEndpointZoneConnection(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + PrivatelinkClient::GetVpcEndpointAttributeOutcome PrivatelinkClient::getVpcEndpointAttribute(const GetVpcEndpointAttributeRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1167,3 +1239,75 @@ PrivatelinkClient::UpdateVpcEndpointServiceAttributeOutcomeCallable PrivatelinkC return task->get_future(); } +PrivatelinkClient::UpdateVpcEndpointServiceResourceAttributeOutcome PrivatelinkClient::updateVpcEndpointServiceResourceAttribute(const UpdateVpcEndpointServiceResourceAttributeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateVpcEndpointServiceResourceAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateVpcEndpointServiceResourceAttributeOutcome(UpdateVpcEndpointServiceResourceAttributeResult(outcome.result())); + else + return UpdateVpcEndpointServiceResourceAttributeOutcome(outcome.error()); +} + +void PrivatelinkClient::updateVpcEndpointServiceResourceAttributeAsync(const UpdateVpcEndpointServiceResourceAttributeRequest& request, const UpdateVpcEndpointServiceResourceAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateVpcEndpointServiceResourceAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +PrivatelinkClient::UpdateVpcEndpointServiceResourceAttributeOutcomeCallable PrivatelinkClient::updateVpcEndpointServiceResourceAttributeCallable(const UpdateVpcEndpointServiceResourceAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateVpcEndpointServiceResourceAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +PrivatelinkClient::UpdateVpcEndpointZoneConnectionResourceAttributeOutcome PrivatelinkClient::updateVpcEndpointZoneConnectionResourceAttribute(const UpdateVpcEndpointZoneConnectionResourceAttributeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateVpcEndpointZoneConnectionResourceAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateVpcEndpointZoneConnectionResourceAttributeOutcome(UpdateVpcEndpointZoneConnectionResourceAttributeResult(outcome.result())); + else + return UpdateVpcEndpointZoneConnectionResourceAttributeOutcome(outcome.error()); +} + +void PrivatelinkClient::updateVpcEndpointZoneConnectionResourceAttributeAsync(const UpdateVpcEndpointZoneConnectionResourceAttributeRequest& request, const UpdateVpcEndpointZoneConnectionResourceAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateVpcEndpointZoneConnectionResourceAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +PrivatelinkClient::UpdateVpcEndpointZoneConnectionResourceAttributeOutcomeCallable PrivatelinkClient::updateVpcEndpointZoneConnectionResourceAttributeCallable(const UpdateVpcEndpointZoneConnectionResourceAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateVpcEndpointZoneConnectionResourceAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/privatelink/src/model/AttachResourceToVpcEndpointServiceRequest.cc b/privatelink/src/model/AttachResourceToVpcEndpointServiceRequest.cc index 958155cb3..b89b503f6 100644 --- a/privatelink/src/model/AttachResourceToVpcEndpointServiceRequest.cc +++ b/privatelink/src/model/AttachResourceToVpcEndpointServiceRequest.cc @@ -70,6 +70,15 @@ void AttachResourceToVpcEndpointServiceRequest::setResourceType(const std::strin setParameter(std::string("ResourceType"), resourceType); } +std::string AttachResourceToVpcEndpointServiceRequest::getZoneId() const { + return zoneId_; +} + +void AttachResourceToVpcEndpointServiceRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setParameter(std::string("ZoneId"), zoneId); +} + std::string AttachResourceToVpcEndpointServiceRequest::getServiceId() const { return serviceId_; } diff --git a/privatelink/src/model/CreateVpcEndpointServiceRequest.cc b/privatelink/src/model/CreateVpcEndpointServiceRequest.cc index 810153397..4d1c569b0 100644 --- a/privatelink/src/model/CreateVpcEndpointServiceRequest.cc +++ b/privatelink/src/model/CreateVpcEndpointServiceRequest.cc @@ -108,6 +108,7 @@ void CreateVpcEndpointServiceRequest::setResource(const std::vector + +using AlibabaCloud::Privatelink::Model::DisableVpcEndpointZoneConnectionRequest; + +DisableVpcEndpointZoneConnectionRequest::DisableVpcEndpointZoneConnectionRequest() + : RpcServiceRequest("privatelink", "2020-04-15", "DisableVpcEndpointZoneConnection") { + setMethod(HttpRequest::Method::Post); +} + +DisableVpcEndpointZoneConnectionRequest::~DisableVpcEndpointZoneConnectionRequest() {} + +std::string DisableVpcEndpointZoneConnectionRequest::getClientToken() const { + return clientToken_; +} + +void DisableVpcEndpointZoneConnectionRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string DisableVpcEndpointZoneConnectionRequest::getEndpointId() const { + return endpointId_; +} + +void DisableVpcEndpointZoneConnectionRequest::setEndpointId(const std::string &endpointId) { + endpointId_ = endpointId; + setParameter(std::string("EndpointId"), endpointId); +} + +bool DisableVpcEndpointZoneConnectionRequest::getReplacedResource() const { + return replacedResource_; +} + +void DisableVpcEndpointZoneConnectionRequest::setReplacedResource(bool replacedResource) { + replacedResource_ = replacedResource; + setParameter(std::string("ReplacedResource"), replacedResource ? "true" : "false"); +} + +std::string DisableVpcEndpointZoneConnectionRequest::getRegionId() const { + return regionId_; +} + +void DisableVpcEndpointZoneConnectionRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +bool DisableVpcEndpointZoneConnectionRequest::getDryRun() const { + return dryRun_; +} + +void DisableVpcEndpointZoneConnectionRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::string DisableVpcEndpointZoneConnectionRequest::getZoneId() const { + return zoneId_; +} + +void DisableVpcEndpointZoneConnectionRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setParameter(std::string("ZoneId"), zoneId); +} + +std::string DisableVpcEndpointZoneConnectionRequest::getServiceId() const { + return serviceId_; +} + +void DisableVpcEndpointZoneConnectionRequest::setServiceId(const std::string &serviceId) { + serviceId_ = serviceId; + setParameter(std::string("ServiceId"), serviceId); +} + diff --git a/privatelink/src/model/DisableVpcEndpointZoneConnectionResult.cc b/privatelink/src/model/DisableVpcEndpointZoneConnectionResult.cc new file mode 100644 index 000000000..9736e55b1 --- /dev/null +++ b/privatelink/src/model/DisableVpcEndpointZoneConnectionResult.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::Privatelink; +using namespace AlibabaCloud::Privatelink::Model; + +DisableVpcEndpointZoneConnectionResult::DisableVpcEndpointZoneConnectionResult() : + ServiceResult() +{} + +DisableVpcEndpointZoneConnectionResult::DisableVpcEndpointZoneConnectionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DisableVpcEndpointZoneConnectionResult::~DisableVpcEndpointZoneConnectionResult() +{} + +void DisableVpcEndpointZoneConnectionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/privatelink/src/model/EnableVpcEndpointZoneConnectionRequest.cc b/privatelink/src/model/EnableVpcEndpointZoneConnectionRequest.cc new file mode 100644 index 000000000..b23b39c4e --- /dev/null +++ b/privatelink/src/model/EnableVpcEndpointZoneConnectionRequest.cc @@ -0,0 +1,81 @@ +/* + * 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::Privatelink::Model::EnableVpcEndpointZoneConnectionRequest; + +EnableVpcEndpointZoneConnectionRequest::EnableVpcEndpointZoneConnectionRequest() + : RpcServiceRequest("privatelink", "2020-04-15", "EnableVpcEndpointZoneConnection") { + setMethod(HttpRequest::Method::Post); +} + +EnableVpcEndpointZoneConnectionRequest::~EnableVpcEndpointZoneConnectionRequest() {} + +std::string EnableVpcEndpointZoneConnectionRequest::getClientToken() const { + return clientToken_; +} + +void EnableVpcEndpointZoneConnectionRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string EnableVpcEndpointZoneConnectionRequest::getEndpointId() const { + return endpointId_; +} + +void EnableVpcEndpointZoneConnectionRequest::setEndpointId(const std::string &endpointId) { + endpointId_ = endpointId; + setParameter(std::string("EndpointId"), endpointId); +} + +std::string EnableVpcEndpointZoneConnectionRequest::getRegionId() const { + return regionId_; +} + +void EnableVpcEndpointZoneConnectionRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +bool EnableVpcEndpointZoneConnectionRequest::getDryRun() const { + return dryRun_; +} + +void EnableVpcEndpointZoneConnectionRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::string EnableVpcEndpointZoneConnectionRequest::getZoneId() const { + return zoneId_; +} + +void EnableVpcEndpointZoneConnectionRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setParameter(std::string("ZoneId"), zoneId); +} + +std::string EnableVpcEndpointZoneConnectionRequest::getServiceId() const { + return serviceId_; +} + +void EnableVpcEndpointZoneConnectionRequest::setServiceId(const std::string &serviceId) { + serviceId_ = serviceId; + setParameter(std::string("ServiceId"), serviceId); +} + diff --git a/privatelink/src/model/EnableVpcEndpointZoneConnectionResult.cc b/privatelink/src/model/EnableVpcEndpointZoneConnectionResult.cc new file mode 100644 index 000000000..cc19228f8 --- /dev/null +++ b/privatelink/src/model/EnableVpcEndpointZoneConnectionResult.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::Privatelink; +using namespace AlibabaCloud::Privatelink::Model; + +EnableVpcEndpointZoneConnectionResult::EnableVpcEndpointZoneConnectionResult() : + ServiceResult() +{} + +EnableVpcEndpointZoneConnectionResult::EnableVpcEndpointZoneConnectionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +EnableVpcEndpointZoneConnectionResult::~EnableVpcEndpointZoneConnectionResult() +{} + +void EnableVpcEndpointZoneConnectionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/privatelink/src/model/ListVpcEndpointConnectionsRequest.cc b/privatelink/src/model/ListVpcEndpointConnectionsRequest.cc index 1ab46b6b7..80bcce4a1 100644 --- a/privatelink/src/model/ListVpcEndpointConnectionsRequest.cc +++ b/privatelink/src/model/ListVpcEndpointConnectionsRequest.cc @@ -106,6 +106,15 @@ void ListVpcEndpointConnectionsRequest::setEniId(const std::string &eniId) { setParameter(std::string("EniId"), eniId); } +std::string ListVpcEndpointConnectionsRequest::getZoneId() const { + return zoneId_; +} + +void ListVpcEndpointConnectionsRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setParameter(std::string("ZoneId"), zoneId); +} + std::string ListVpcEndpointConnectionsRequest::getServiceId() const { return serviceId_; } diff --git a/privatelink/src/model/UpdateVpcEndpointServiceResourceAttributeRequest.cc b/privatelink/src/model/UpdateVpcEndpointServiceResourceAttributeRequest.cc new file mode 100644 index 000000000..d8df603d1 --- /dev/null +++ b/privatelink/src/model/UpdateVpcEndpointServiceResourceAttributeRequest.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::Privatelink::Model::UpdateVpcEndpointServiceResourceAttributeRequest; + +UpdateVpcEndpointServiceResourceAttributeRequest::UpdateVpcEndpointServiceResourceAttributeRequest() + : RpcServiceRequest("privatelink", "2020-04-15", "UpdateVpcEndpointServiceResourceAttribute") { + setMethod(HttpRequest::Method::Post); +} + +UpdateVpcEndpointServiceResourceAttributeRequest::~UpdateVpcEndpointServiceResourceAttributeRequest() {} + +std::string UpdateVpcEndpointServiceResourceAttributeRequest::getClientToken() const { + return clientToken_; +} + +void UpdateVpcEndpointServiceResourceAttributeRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string UpdateVpcEndpointServiceResourceAttributeRequest::getRegionId() const { + return regionId_; +} + +void UpdateVpcEndpointServiceResourceAttributeRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +bool UpdateVpcEndpointServiceResourceAttributeRequest::getAutoAllocatedEnabled() const { + return autoAllocatedEnabled_; +} + +void UpdateVpcEndpointServiceResourceAttributeRequest::setAutoAllocatedEnabled(bool autoAllocatedEnabled) { + autoAllocatedEnabled_ = autoAllocatedEnabled; + setParameter(std::string("AutoAllocatedEnabled"), autoAllocatedEnabled ? "true" : "false"); +} + +std::string UpdateVpcEndpointServiceResourceAttributeRequest::getResourceId() const { + return resourceId_; +} + +void UpdateVpcEndpointServiceResourceAttributeRequest::setResourceId(const std::string &resourceId) { + resourceId_ = resourceId; + setParameter(std::string("ResourceId"), resourceId); +} + +bool UpdateVpcEndpointServiceResourceAttributeRequest::getDryRun() const { + return dryRun_; +} + +void UpdateVpcEndpointServiceResourceAttributeRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::string UpdateVpcEndpointServiceResourceAttributeRequest::getResourceType() const { + return resourceType_; +} + +void UpdateVpcEndpointServiceResourceAttributeRequest::setResourceType(const std::string &resourceType) { + resourceType_ = resourceType; + setParameter(std::string("ResourceType"), resourceType); +} + +std::string UpdateVpcEndpointServiceResourceAttributeRequest::getZoneId() const { + return zoneId_; +} + +void UpdateVpcEndpointServiceResourceAttributeRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setParameter(std::string("ZoneId"), zoneId); +} + +std::string UpdateVpcEndpointServiceResourceAttributeRequest::getServiceId() const { + return serviceId_; +} + +void UpdateVpcEndpointServiceResourceAttributeRequest::setServiceId(const std::string &serviceId) { + serviceId_ = serviceId; + setParameter(std::string("ServiceId"), serviceId); +} + diff --git a/privatelink/src/model/UpdateVpcEndpointServiceResourceAttributeResult.cc b/privatelink/src/model/UpdateVpcEndpointServiceResourceAttributeResult.cc new file mode 100644 index 000000000..54bc09dfb --- /dev/null +++ b/privatelink/src/model/UpdateVpcEndpointServiceResourceAttributeResult.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::Privatelink; +using namespace AlibabaCloud::Privatelink::Model; + +UpdateVpcEndpointServiceResourceAttributeResult::UpdateVpcEndpointServiceResourceAttributeResult() : + ServiceResult() +{} + +UpdateVpcEndpointServiceResourceAttributeResult::UpdateVpcEndpointServiceResourceAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateVpcEndpointServiceResourceAttributeResult::~UpdateVpcEndpointServiceResourceAttributeResult() +{} + +void UpdateVpcEndpointServiceResourceAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/privatelink/src/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.cc b/privatelink/src/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.cc new file mode 100644 index 000000000..d2d824a1a --- /dev/null +++ b/privatelink/src/model/UpdateVpcEndpointZoneConnectionResourceAttributeRequest.cc @@ -0,0 +1,117 @@ +/* + * 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::Privatelink::Model::UpdateVpcEndpointZoneConnectionResourceAttributeRequest; + +UpdateVpcEndpointZoneConnectionResourceAttributeRequest::UpdateVpcEndpointZoneConnectionResourceAttributeRequest() + : RpcServiceRequest("privatelink", "2020-04-15", "UpdateVpcEndpointZoneConnectionResourceAttribute") { + setMethod(HttpRequest::Method::Post); +} + +UpdateVpcEndpointZoneConnectionResourceAttributeRequest::~UpdateVpcEndpointZoneConnectionResourceAttributeRequest() {} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getClientToken() const { + return clientToken_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getEndpointId() const { + return endpointId_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setEndpointId(const std::string &endpointId) { + endpointId_ = endpointId; + setParameter(std::string("EndpointId"), endpointId); +} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getRegionId() const { + return regionId_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getResourceId() const { + return resourceId_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setResourceId(const std::string &resourceId) { + resourceId_ = resourceId; + setParameter(std::string("ResourceId"), resourceId); +} + +bool UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getDryRun() const { + return dryRun_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getResourceAllocateMode() const { + return resourceAllocateMode_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setResourceAllocateMode(const std::string &resourceAllocateMode) { + resourceAllocateMode_ = resourceAllocateMode; + setParameter(std::string("ResourceAllocateMode"), resourceAllocateMode); +} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getResourceType() const { + return resourceType_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setResourceType(const std::string &resourceType) { + resourceType_ = resourceType; + setParameter(std::string("ResourceType"), resourceType); +} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getResourceReplaceMode() const { + return resourceReplaceMode_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setResourceReplaceMode(const std::string &resourceReplaceMode) { + resourceReplaceMode_ = resourceReplaceMode; + setParameter(std::string("ResourceReplaceMode"), resourceReplaceMode); +} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getZoneId() const { + return zoneId_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setParameter(std::string("ZoneId"), zoneId); +} + +std::string UpdateVpcEndpointZoneConnectionResourceAttributeRequest::getServiceId() const { + return serviceId_; +} + +void UpdateVpcEndpointZoneConnectionResourceAttributeRequest::setServiceId(const std::string &serviceId) { + serviceId_ = serviceId; + setParameter(std::string("ServiceId"), serviceId); +} + diff --git a/privatelink/src/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.cc b/privatelink/src/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.cc new file mode 100644 index 000000000..8bf6d0b90 --- /dev/null +++ b/privatelink/src/model/UpdateVpcEndpointZoneConnectionResourceAttributeResult.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::Privatelink; +using namespace AlibabaCloud::Privatelink::Model; + +UpdateVpcEndpointZoneConnectionResourceAttributeResult::UpdateVpcEndpointZoneConnectionResourceAttributeResult() : + ServiceResult() +{} + +UpdateVpcEndpointZoneConnectionResourceAttributeResult::UpdateVpcEndpointZoneConnectionResourceAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateVpcEndpointZoneConnectionResourceAttributeResult::~UpdateVpcEndpointZoneConnectionResourceAttributeResult() +{} + +void UpdateVpcEndpointZoneConnectionResourceAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} +