diff --git a/VERSION b/VERSION index 5eadbcfd0..edc2330c9 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1407 \ No newline at end of file +1.36.1408 \ No newline at end of file diff --git a/dbfs/CMakeLists.txt b/dbfs/CMakeLists.txt index ff12742f3..4b953fc88 100644 --- a/dbfs/CMakeLists.txt +++ b/dbfs/CMakeLists.txt @@ -23,6 +23,8 @@ set(dbfs_public_header set(dbfs_public_header_model include/alibabacloud/dbfs/model/AddTagsBatchRequest.h include/alibabacloud/dbfs/model/AddTagsBatchResult.h + include/alibabacloud/dbfs/model/ApplyAutoSnapshotPolicyRequest.h + include/alibabacloud/dbfs/model/ApplyAutoSnapshotPolicyResult.h include/alibabacloud/dbfs/model/AttachDbfsRequest.h include/alibabacloud/dbfs/model/AttachDbfsResult.h include/alibabacloud/dbfs/model/CancelAutoSnapshotPolicyRequest.h @@ -35,6 +37,8 @@ set(dbfs_public_header_model include/alibabacloud/dbfs/model/CreateServiceLinkedRoleResult.h include/alibabacloud/dbfs/model/CreateSnapshotRequest.h include/alibabacloud/dbfs/model/CreateSnapshotResult.h + include/alibabacloud/dbfs/model/DeleteAutoSnapshotPolicyRequest.h + include/alibabacloud/dbfs/model/DeleteAutoSnapshotPolicyResult.h include/alibabacloud/dbfs/model/DeleteDbfsRequest.h include/alibabacloud/dbfs/model/DeleteDbfsResult.h include/alibabacloud/dbfs/model/DeleteSnapshotRequest.h @@ -47,10 +51,18 @@ set(dbfs_public_header_model include/alibabacloud/dbfs/model/DescribeInstanceTypesResult.h include/alibabacloud/dbfs/model/DetachDbfsRequest.h include/alibabacloud/dbfs/model/DetachDbfsResult.h + include/alibabacloud/dbfs/model/GetAutoSnapshotPolicyRequest.h + include/alibabacloud/dbfs/model/GetAutoSnapshotPolicyResult.h include/alibabacloud/dbfs/model/GetDbfsRequest.h include/alibabacloud/dbfs/model/GetDbfsResult.h include/alibabacloud/dbfs/model/GetServiceLinkedRoleRequest.h include/alibabacloud/dbfs/model/GetServiceLinkedRoleResult.h + include/alibabacloud/dbfs/model/ListAutoSnapshotPoliciesRequest.h + include/alibabacloud/dbfs/model/ListAutoSnapshotPoliciesResult.h + include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyAppliedDbfsRequest.h + include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyAppliedDbfsResult.h + include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyUnappliedDbfsRequest.h + include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyUnappliedDbfsResult.h include/alibabacloud/dbfs/model/ListDbfsRequest.h include/alibabacloud/dbfs/model/ListDbfsResult.h include/alibabacloud/dbfs/model/ListDbfsAttachableEcsInstancesRequest.h @@ -63,6 +75,10 @@ set(dbfs_public_header_model include/alibabacloud/dbfs/model/ListTagKeysResult.h include/alibabacloud/dbfs/model/ListTagValuesRequest.h include/alibabacloud/dbfs/model/ListTagValuesResult.h + include/alibabacloud/dbfs/model/ModifyAutoSnapshotPolicyRequest.h + include/alibabacloud/dbfs/model/ModifyAutoSnapshotPolicyResult.h + include/alibabacloud/dbfs/model/ModifySnapshotAttributeRequest.h + include/alibabacloud/dbfs/model/ModifySnapshotAttributeResult.h include/alibabacloud/dbfs/model/RenameDbfsRequest.h include/alibabacloud/dbfs/model/RenameDbfsResult.h include/alibabacloud/dbfs/model/ResizeDbfsRequest.h @@ -76,6 +92,8 @@ set(dbfs_src src/DBFSClient.cc src/model/AddTagsBatchRequest.cc src/model/AddTagsBatchResult.cc + src/model/ApplyAutoSnapshotPolicyRequest.cc + src/model/ApplyAutoSnapshotPolicyResult.cc src/model/AttachDbfsRequest.cc src/model/AttachDbfsResult.cc src/model/CancelAutoSnapshotPolicyRequest.cc @@ -88,6 +106,8 @@ set(dbfs_src src/model/CreateServiceLinkedRoleResult.cc src/model/CreateSnapshotRequest.cc src/model/CreateSnapshotResult.cc + src/model/DeleteAutoSnapshotPolicyRequest.cc + src/model/DeleteAutoSnapshotPolicyResult.cc src/model/DeleteDbfsRequest.cc src/model/DeleteDbfsResult.cc src/model/DeleteSnapshotRequest.cc @@ -100,10 +120,18 @@ set(dbfs_src src/model/DescribeInstanceTypesResult.cc src/model/DetachDbfsRequest.cc src/model/DetachDbfsResult.cc + src/model/GetAutoSnapshotPolicyRequest.cc + src/model/GetAutoSnapshotPolicyResult.cc src/model/GetDbfsRequest.cc src/model/GetDbfsResult.cc src/model/GetServiceLinkedRoleRequest.cc src/model/GetServiceLinkedRoleResult.cc + src/model/ListAutoSnapshotPoliciesRequest.cc + src/model/ListAutoSnapshotPoliciesResult.cc + src/model/ListAutoSnapshotPolicyAppliedDbfsRequest.cc + src/model/ListAutoSnapshotPolicyAppliedDbfsResult.cc + src/model/ListAutoSnapshotPolicyUnappliedDbfsRequest.cc + src/model/ListAutoSnapshotPolicyUnappliedDbfsResult.cc src/model/ListDbfsRequest.cc src/model/ListDbfsResult.cc src/model/ListDbfsAttachableEcsInstancesRequest.cc @@ -116,6 +144,10 @@ set(dbfs_src src/model/ListTagKeysResult.cc src/model/ListTagValuesRequest.cc src/model/ListTagValuesResult.cc + src/model/ModifyAutoSnapshotPolicyRequest.cc + src/model/ModifyAutoSnapshotPolicyResult.cc + src/model/ModifySnapshotAttributeRequest.cc + src/model/ModifySnapshotAttributeResult.cc src/model/RenameDbfsRequest.cc src/model/RenameDbfsResult.cc src/model/ResizeDbfsRequest.cc diff --git a/dbfs/include/alibabacloud/dbfs/DBFSClient.h b/dbfs/include/alibabacloud/dbfs/DBFSClient.h index 9e0e70db2..43fc5f5df 100644 --- a/dbfs/include/alibabacloud/dbfs/DBFSClient.h +++ b/dbfs/include/alibabacloud/dbfs/DBFSClient.h @@ -24,6 +24,8 @@ #include "DBFSExport.h" #include "model/AddTagsBatchRequest.h" #include "model/AddTagsBatchResult.h" +#include "model/ApplyAutoSnapshotPolicyRequest.h" +#include "model/ApplyAutoSnapshotPolicyResult.h" #include "model/AttachDbfsRequest.h" #include "model/AttachDbfsResult.h" #include "model/CancelAutoSnapshotPolicyRequest.h" @@ -36,6 +38,8 @@ #include "model/CreateServiceLinkedRoleResult.h" #include "model/CreateSnapshotRequest.h" #include "model/CreateSnapshotResult.h" +#include "model/DeleteAutoSnapshotPolicyRequest.h" +#include "model/DeleteAutoSnapshotPolicyResult.h" #include "model/DeleteDbfsRequest.h" #include "model/DeleteDbfsResult.h" #include "model/DeleteSnapshotRequest.h" @@ -48,10 +52,18 @@ #include "model/DescribeInstanceTypesResult.h" #include "model/DetachDbfsRequest.h" #include "model/DetachDbfsResult.h" +#include "model/GetAutoSnapshotPolicyRequest.h" +#include "model/GetAutoSnapshotPolicyResult.h" #include "model/GetDbfsRequest.h" #include "model/GetDbfsResult.h" #include "model/GetServiceLinkedRoleRequest.h" #include "model/GetServiceLinkedRoleResult.h" +#include "model/ListAutoSnapshotPoliciesRequest.h" +#include "model/ListAutoSnapshotPoliciesResult.h" +#include "model/ListAutoSnapshotPolicyAppliedDbfsRequest.h" +#include "model/ListAutoSnapshotPolicyAppliedDbfsResult.h" +#include "model/ListAutoSnapshotPolicyUnappliedDbfsRequest.h" +#include "model/ListAutoSnapshotPolicyUnappliedDbfsResult.h" #include "model/ListDbfsRequest.h" #include "model/ListDbfsResult.h" #include "model/ListDbfsAttachableEcsInstancesRequest.h" @@ -64,6 +76,10 @@ #include "model/ListTagKeysResult.h" #include "model/ListTagValuesRequest.h" #include "model/ListTagValuesResult.h" +#include "model/ModifyAutoSnapshotPolicyRequest.h" +#include "model/ModifyAutoSnapshotPolicyResult.h" +#include "model/ModifySnapshotAttributeRequest.h" +#include "model/ModifySnapshotAttributeResult.h" #include "model/RenameDbfsRequest.h" #include "model/RenameDbfsResult.h" #include "model/ResizeDbfsRequest.h" @@ -84,6 +100,9 @@ namespace AlibabaCloud typedef Outcome AddTagsBatchOutcome; typedef std::future AddTagsBatchOutcomeCallable; typedef std::function&)> AddTagsBatchAsyncHandler; + typedef Outcome ApplyAutoSnapshotPolicyOutcome; + typedef std::future ApplyAutoSnapshotPolicyOutcomeCallable; + typedef std::function&)> ApplyAutoSnapshotPolicyAsyncHandler; typedef Outcome AttachDbfsOutcome; typedef std::future AttachDbfsOutcomeCallable; typedef std::function&)> AttachDbfsAsyncHandler; @@ -102,6 +121,9 @@ namespace AlibabaCloud typedef Outcome CreateSnapshotOutcome; typedef std::future CreateSnapshotOutcomeCallable; typedef std::function&)> CreateSnapshotAsyncHandler; + typedef Outcome DeleteAutoSnapshotPolicyOutcome; + typedef std::future DeleteAutoSnapshotPolicyOutcomeCallable; + typedef std::function&)> DeleteAutoSnapshotPolicyAsyncHandler; typedef Outcome DeleteDbfsOutcome; typedef std::future DeleteDbfsOutcomeCallable; typedef std::function&)> DeleteDbfsAsyncHandler; @@ -120,12 +142,24 @@ namespace AlibabaCloud typedef Outcome DetachDbfsOutcome; typedef std::future DetachDbfsOutcomeCallable; typedef std::function&)> DetachDbfsAsyncHandler; + typedef Outcome GetAutoSnapshotPolicyOutcome; + typedef std::future GetAutoSnapshotPolicyOutcomeCallable; + typedef std::function&)> GetAutoSnapshotPolicyAsyncHandler; typedef Outcome GetDbfsOutcome; typedef std::future GetDbfsOutcomeCallable; typedef std::function&)> GetDbfsAsyncHandler; typedef Outcome GetServiceLinkedRoleOutcome; typedef std::future GetServiceLinkedRoleOutcomeCallable; typedef std::function&)> GetServiceLinkedRoleAsyncHandler; + typedef Outcome ListAutoSnapshotPoliciesOutcome; + typedef std::future ListAutoSnapshotPoliciesOutcomeCallable; + typedef std::function&)> ListAutoSnapshotPoliciesAsyncHandler; + typedef Outcome ListAutoSnapshotPolicyAppliedDbfsOutcome; + typedef std::future ListAutoSnapshotPolicyAppliedDbfsOutcomeCallable; + typedef std::function&)> ListAutoSnapshotPolicyAppliedDbfsAsyncHandler; + typedef Outcome ListAutoSnapshotPolicyUnappliedDbfsOutcome; + typedef std::future ListAutoSnapshotPolicyUnappliedDbfsOutcomeCallable; + typedef std::function&)> ListAutoSnapshotPolicyUnappliedDbfsAsyncHandler; typedef Outcome ListDbfsOutcome; typedef std::future ListDbfsOutcomeCallable; typedef std::function&)> ListDbfsAsyncHandler; @@ -144,6 +178,12 @@ namespace AlibabaCloud typedef Outcome ListTagValuesOutcome; typedef std::future ListTagValuesOutcomeCallable; typedef std::function&)> ListTagValuesAsyncHandler; + typedef Outcome ModifyAutoSnapshotPolicyOutcome; + typedef std::future ModifyAutoSnapshotPolicyOutcomeCallable; + typedef std::function&)> ModifyAutoSnapshotPolicyAsyncHandler; + typedef Outcome ModifySnapshotAttributeOutcome; + typedef std::future ModifySnapshotAttributeOutcomeCallable; + typedef std::function&)> ModifySnapshotAttributeAsyncHandler; typedef Outcome RenameDbfsOutcome; typedef std::future RenameDbfsOutcomeCallable; typedef std::function&)> RenameDbfsAsyncHandler; @@ -164,6 +204,9 @@ namespace AlibabaCloud AddTagsBatchOutcome addTagsBatch(const Model::AddTagsBatchRequest &request)const; void addTagsBatchAsync(const Model::AddTagsBatchRequest& request, const AddTagsBatchAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AddTagsBatchOutcomeCallable addTagsBatchCallable(const Model::AddTagsBatchRequest& request) const; + ApplyAutoSnapshotPolicyOutcome applyAutoSnapshotPolicy(const Model::ApplyAutoSnapshotPolicyRequest &request)const; + void applyAutoSnapshotPolicyAsync(const Model::ApplyAutoSnapshotPolicyRequest& request, const ApplyAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ApplyAutoSnapshotPolicyOutcomeCallable applyAutoSnapshotPolicyCallable(const Model::ApplyAutoSnapshotPolicyRequest& request) const; AttachDbfsOutcome attachDbfs(const Model::AttachDbfsRequest &request)const; void attachDbfsAsync(const Model::AttachDbfsRequest& request, const AttachDbfsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AttachDbfsOutcomeCallable attachDbfsCallable(const Model::AttachDbfsRequest& request) const; @@ -182,6 +225,9 @@ namespace AlibabaCloud CreateSnapshotOutcome createSnapshot(const Model::CreateSnapshotRequest &request)const; void createSnapshotAsync(const Model::CreateSnapshotRequest& request, const CreateSnapshotAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateSnapshotOutcomeCallable createSnapshotCallable(const Model::CreateSnapshotRequest& request) const; + DeleteAutoSnapshotPolicyOutcome deleteAutoSnapshotPolicy(const Model::DeleteAutoSnapshotPolicyRequest &request)const; + void deleteAutoSnapshotPolicyAsync(const Model::DeleteAutoSnapshotPolicyRequest& request, const DeleteAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteAutoSnapshotPolicyOutcomeCallable deleteAutoSnapshotPolicyCallable(const Model::DeleteAutoSnapshotPolicyRequest& request) const; DeleteDbfsOutcome deleteDbfs(const Model::DeleteDbfsRequest &request)const; void deleteDbfsAsync(const Model::DeleteDbfsRequest& request, const DeleteDbfsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DeleteDbfsOutcomeCallable deleteDbfsCallable(const Model::DeleteDbfsRequest& request) const; @@ -200,12 +246,24 @@ namespace AlibabaCloud DetachDbfsOutcome detachDbfs(const Model::DetachDbfsRequest &request)const; void detachDbfsAsync(const Model::DetachDbfsRequest& request, const DetachDbfsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DetachDbfsOutcomeCallable detachDbfsCallable(const Model::DetachDbfsRequest& request) const; + GetAutoSnapshotPolicyOutcome getAutoSnapshotPolicy(const Model::GetAutoSnapshotPolicyRequest &request)const; + void getAutoSnapshotPolicyAsync(const Model::GetAutoSnapshotPolicyRequest& request, const GetAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetAutoSnapshotPolicyOutcomeCallable getAutoSnapshotPolicyCallable(const Model::GetAutoSnapshotPolicyRequest& request) const; GetDbfsOutcome getDbfs(const Model::GetDbfsRequest &request)const; void getDbfsAsync(const Model::GetDbfsRequest& request, const GetDbfsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetDbfsOutcomeCallable getDbfsCallable(const Model::GetDbfsRequest& request) const; GetServiceLinkedRoleOutcome getServiceLinkedRole(const Model::GetServiceLinkedRoleRequest &request)const; void getServiceLinkedRoleAsync(const Model::GetServiceLinkedRoleRequest& request, const GetServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetServiceLinkedRoleOutcomeCallable getServiceLinkedRoleCallable(const Model::GetServiceLinkedRoleRequest& request) const; + ListAutoSnapshotPoliciesOutcome listAutoSnapshotPolicies(const Model::ListAutoSnapshotPoliciesRequest &request)const; + void listAutoSnapshotPoliciesAsync(const Model::ListAutoSnapshotPoliciesRequest& request, const ListAutoSnapshotPoliciesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAutoSnapshotPoliciesOutcomeCallable listAutoSnapshotPoliciesCallable(const Model::ListAutoSnapshotPoliciesRequest& request) const; + ListAutoSnapshotPolicyAppliedDbfsOutcome listAutoSnapshotPolicyAppliedDbfs(const Model::ListAutoSnapshotPolicyAppliedDbfsRequest &request)const; + void listAutoSnapshotPolicyAppliedDbfsAsync(const Model::ListAutoSnapshotPolicyAppliedDbfsRequest& request, const ListAutoSnapshotPolicyAppliedDbfsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAutoSnapshotPolicyAppliedDbfsOutcomeCallable listAutoSnapshotPolicyAppliedDbfsCallable(const Model::ListAutoSnapshotPolicyAppliedDbfsRequest& request) const; + ListAutoSnapshotPolicyUnappliedDbfsOutcome listAutoSnapshotPolicyUnappliedDbfs(const Model::ListAutoSnapshotPolicyUnappliedDbfsRequest &request)const; + void listAutoSnapshotPolicyUnappliedDbfsAsync(const Model::ListAutoSnapshotPolicyUnappliedDbfsRequest& request, const ListAutoSnapshotPolicyUnappliedDbfsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAutoSnapshotPolicyUnappliedDbfsOutcomeCallable listAutoSnapshotPolicyUnappliedDbfsCallable(const Model::ListAutoSnapshotPolicyUnappliedDbfsRequest& request) const; ListDbfsOutcome listDbfs(const Model::ListDbfsRequest &request)const; void listDbfsAsync(const Model::ListDbfsRequest& request, const ListDbfsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListDbfsOutcomeCallable listDbfsCallable(const Model::ListDbfsRequest& request) const; @@ -224,6 +282,12 @@ namespace AlibabaCloud ListTagValuesOutcome listTagValues(const Model::ListTagValuesRequest &request)const; void listTagValuesAsync(const Model::ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListTagValuesOutcomeCallable listTagValuesCallable(const Model::ListTagValuesRequest& request) const; + ModifyAutoSnapshotPolicyOutcome modifyAutoSnapshotPolicy(const Model::ModifyAutoSnapshotPolicyRequest &request)const; + void modifyAutoSnapshotPolicyAsync(const Model::ModifyAutoSnapshotPolicyRequest& request, const ModifyAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyAutoSnapshotPolicyOutcomeCallable modifyAutoSnapshotPolicyCallable(const Model::ModifyAutoSnapshotPolicyRequest& request) const; + ModifySnapshotAttributeOutcome modifySnapshotAttribute(const Model::ModifySnapshotAttributeRequest &request)const; + void modifySnapshotAttributeAsync(const Model::ModifySnapshotAttributeRequest& request, const ModifySnapshotAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifySnapshotAttributeOutcomeCallable modifySnapshotAttributeCallable(const Model::ModifySnapshotAttributeRequest& request) const; RenameDbfsOutcome renameDbfs(const Model::RenameDbfsRequest &request)const; void renameDbfsAsync(const Model::RenameDbfsRequest& request, const RenameDbfsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; RenameDbfsOutcomeCallable renameDbfsCallable(const Model::RenameDbfsRequest& request) const; diff --git a/dbfs/include/alibabacloud/dbfs/model/ApplyAutoSnapshotPolicyRequest.h b/dbfs/include/alibabacloud/dbfs/model/ApplyAutoSnapshotPolicyRequest.h new file mode 100644 index 000000000..e3962103f --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ApplyAutoSnapshotPolicyRequest.h @@ -0,0 +1,48 @@ +/* + * 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_DBFS_MODEL_APPLYAUTOSNAPSHOTPOLICYREQUEST_H_ +#define ALIBABACLOUD_DBFS_MODEL_APPLYAUTOSNAPSHOTPOLICYREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace DBFS { +namespace Model { +class ALIBABACLOUD_DBFS_EXPORT ApplyAutoSnapshotPolicyRequest : public RpcServiceRequest { +public: + ApplyAutoSnapshotPolicyRequest(); + ~ApplyAutoSnapshotPolicyRequest(); + std::vector getDbfsIds() const; + void setDbfsIds(const std::vector &dbfsIds); + std::string getPolicyId() const; + void setPolicyId(const std::string &policyId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + +private: + std::vector dbfsIds_; + std::string policyId_; + std::string regionId_; +}; +} // namespace Model +} // namespace DBFS +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DBFS_MODEL_APPLYAUTOSNAPSHOTPOLICYREQUEST_H_ diff --git a/dbfs/include/alibabacloud/dbfs/model/ApplyAutoSnapshotPolicyResult.h b/dbfs/include/alibabacloud/dbfs/model/ApplyAutoSnapshotPolicyResult.h new file mode 100644 index 000000000..fe4f69e90 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ApplyAutoSnapshotPolicyResult.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_DBFS_MODEL_APPLYAUTOSNAPSHOTPOLICYRESULT_H_ +#define ALIBABACLOUD_DBFS_MODEL_APPLYAUTOSNAPSHOTPOLICYRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DBFS + { + namespace Model + { + class ALIBABACLOUD_DBFS_EXPORT ApplyAutoSnapshotPolicyResult : public ServiceResult + { + public: + + + ApplyAutoSnapshotPolicyResult(); + explicit ApplyAutoSnapshotPolicyResult(const std::string &payload); + ~ApplyAutoSnapshotPolicyResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_DBFS_MODEL_APPLYAUTOSNAPSHOTPOLICYRESULT_H_ \ No newline at end of file diff --git a/dbfs/include/alibabacloud/dbfs/model/DeleteAutoSnapshotPolicyRequest.h b/dbfs/include/alibabacloud/dbfs/model/DeleteAutoSnapshotPolicyRequest.h new file mode 100644 index 000000000..49b301ca8 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/DeleteAutoSnapshotPolicyRequest.h @@ -0,0 +1,45 @@ +/* + * 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_DBFS_MODEL_DELETEAUTOSNAPSHOTPOLICYREQUEST_H_ +#define ALIBABACLOUD_DBFS_MODEL_DELETEAUTOSNAPSHOTPOLICYREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace DBFS { +namespace Model { +class ALIBABACLOUD_DBFS_EXPORT DeleteAutoSnapshotPolicyRequest : public RpcServiceRequest { +public: + DeleteAutoSnapshotPolicyRequest(); + ~DeleteAutoSnapshotPolicyRequest(); + std::string getPolicyId() const; + void setPolicyId(const std::string &policyId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + +private: + std::string policyId_; + std::string regionId_; +}; +} // namespace Model +} // namespace DBFS +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DBFS_MODEL_DELETEAUTOSNAPSHOTPOLICYREQUEST_H_ diff --git a/dbfs/include/alibabacloud/dbfs/model/DeleteAutoSnapshotPolicyResult.h b/dbfs/include/alibabacloud/dbfs/model/DeleteAutoSnapshotPolicyResult.h new file mode 100644 index 000000000..867c88925 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/DeleteAutoSnapshotPolicyResult.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_DBFS_MODEL_DELETEAUTOSNAPSHOTPOLICYRESULT_H_ +#define ALIBABACLOUD_DBFS_MODEL_DELETEAUTOSNAPSHOTPOLICYRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DBFS + { + namespace Model + { + class ALIBABACLOUD_DBFS_EXPORT DeleteAutoSnapshotPolicyResult : public ServiceResult + { + public: + + + DeleteAutoSnapshotPolicyResult(); + explicit DeleteAutoSnapshotPolicyResult(const std::string &payload); + ~DeleteAutoSnapshotPolicyResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_DBFS_MODEL_DELETEAUTOSNAPSHOTPOLICYRESULT_H_ \ No newline at end of file diff --git a/dbfs/include/alibabacloud/dbfs/model/GetAutoSnapshotPolicyRequest.h b/dbfs/include/alibabacloud/dbfs/model/GetAutoSnapshotPolicyRequest.h new file mode 100644 index 000000000..a723f9e8c --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/GetAutoSnapshotPolicyRequest.h @@ -0,0 +1,45 @@ +/* + * 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_DBFS_MODEL_GETAUTOSNAPSHOTPOLICYREQUEST_H_ +#define ALIBABACLOUD_DBFS_MODEL_GETAUTOSNAPSHOTPOLICYREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace DBFS { +namespace Model { +class ALIBABACLOUD_DBFS_EXPORT GetAutoSnapshotPolicyRequest : public RpcServiceRequest { +public: + GetAutoSnapshotPolicyRequest(); + ~GetAutoSnapshotPolicyRequest(); + std::string getPolicyId() const; + void setPolicyId(const std::string &policyId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + +private: + std::string policyId_; + std::string regionId_; +}; +} // namespace Model +} // namespace DBFS +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DBFS_MODEL_GETAUTOSNAPSHOTPOLICYREQUEST_H_ diff --git a/dbfs/include/alibabacloud/dbfs/model/GetAutoSnapshotPolicyResult.h b/dbfs/include/alibabacloud/dbfs/model/GetAutoSnapshotPolicyResult.h new file mode 100644 index 000000000..75dfae345 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/GetAutoSnapshotPolicyResult.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_DBFS_MODEL_GETAUTOSNAPSHOTPOLICYRESULT_H_ +#define ALIBABACLOUD_DBFS_MODEL_GETAUTOSNAPSHOTPOLICYRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DBFS + { + namespace Model + { + class ALIBABACLOUD_DBFS_EXPORT GetAutoSnapshotPolicyResult : public ServiceResult + { + public: + struct Data + { + std::string status; + std::string lastModified; + std::vector timePoints; + std::string accountId; + int appliedDbfsNumber; + std::string createdTime; + std::string policyName; + std::string statusDetail; + int retentionDays; + std::string regionId; + std::vector repeatWeekdays; + std::string policyId; + }; + + + GetAutoSnapshotPolicyResult(); + explicit GetAutoSnapshotPolicyResult(const std::string &payload); + ~GetAutoSnapshotPolicyResult(); + Data getData()const; + + protected: + void parse(const std::string &payload); + private: + Data data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DBFS_MODEL_GETAUTOSNAPSHOTPOLICYRESULT_H_ \ No newline at end of file diff --git a/dbfs/include/alibabacloud/dbfs/model/GetDbfsResult.h b/dbfs/include/alibabacloud/dbfs/model/GetDbfsResult.h index 192968f83..cc33955da 100644 --- a/dbfs/include/alibabacloud/dbfs/model/GetDbfsResult.h +++ b/dbfs/include/alibabacloud/dbfs/model/GetDbfsResult.h @@ -34,6 +34,13 @@ namespace AlibabaCloud public: struct DBFSInfo { + struct SnapshotInfo + { + int snapshotCount; + long totalSize; + std::string linkId; + std::string policyId; + }; struct TagList { std::string tagKey; @@ -70,6 +77,7 @@ namespace AlibabaCloud bool enableRaid; std::string performanceLevel; std::string payType; + SnapshotInfo snapshotInfo; std::string fsName; std::string usedScene; std::string regionId; diff --git a/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPoliciesRequest.h b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPoliciesRequest.h new file mode 100644 index 000000000..d74a11805 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPoliciesRequest.h @@ -0,0 +1,54 @@ +/* + * 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_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICIESREQUEST_H_ +#define ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICIESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace DBFS { +namespace Model { +class ALIBABACLOUD_DBFS_EXPORT ListAutoSnapshotPoliciesRequest : public RpcServiceRequest { +public: + ListAutoSnapshotPoliciesRequest(); + ~ListAutoSnapshotPoliciesRequest(); + std::string getFilterValue() const; + void setFilterValue(const std::string &filterValue); + int getPageNumber() const; + void setPageNumber(int pageNumber); + std::string getFilterKey() const; + void setFilterKey(const std::string &filterKey); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + int getPageSize() const; + void setPageSize(int pageSize); + +private: + std::string filterValue_; + int pageNumber_; + std::string filterKey_; + std::string regionId_; + int pageSize_; +}; +} // namespace Model +} // namespace DBFS +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICIESREQUEST_H_ diff --git a/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPoliciesResult.h b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPoliciesResult.h new file mode 100644 index 000000000..e6b679dee --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPoliciesResult.h @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICIESRESULT_H_ +#define ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICIESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DBFS + { + namespace Model + { + class ALIBABACLOUD_DBFS_EXPORT ListAutoSnapshotPoliciesResult : public ServiceResult + { + public: + struct SnapshotPoliciesItem + { + std::string status; + std::string lastModified; + std::vector timePoints; + std::string accountId; + int appliedDbfsNumber; + std::string createdTime; + std::string policyName; + std::string statusDetail; + int retentionDays; + std::string regionId; + std::vector repeatWeekdays; + std::string policyId; + }; + + + ListAutoSnapshotPoliciesResult(); + explicit ListAutoSnapshotPoliciesResult(const std::string &payload); + ~ListAutoSnapshotPoliciesResult(); + int getTotalCount()const; + int getPageSize()const; + int getPageNumber()const; + std::vector getSnapshotPolicies()const; + + protected: + void parse(const std::string &payload); + private: + int totalCount_; + int pageSize_; + int pageNumber_; + std::vector snapshotPolicies_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICIESRESULT_H_ \ No newline at end of file diff --git a/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyAppliedDbfsRequest.h b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyAppliedDbfsRequest.h new file mode 100644 index 000000000..a4594b73f --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyAppliedDbfsRequest.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_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYAPPLIEDDBFSREQUEST_H_ +#define ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYAPPLIEDDBFSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace DBFS { +namespace Model { +class ALIBABACLOUD_DBFS_EXPORT ListAutoSnapshotPolicyAppliedDbfsRequest : public RpcServiceRequest { +public: + ListAutoSnapshotPolicyAppliedDbfsRequest(); + ~ListAutoSnapshotPolicyAppliedDbfsRequest(); + std::string getFilterValue() const; + void setFilterValue(const std::string &filterValue); + int getPageNumber() const; + void setPageNumber(int pageNumber); + std::string getFilterKey() const; + void setFilterKey(const std::string &filterKey); + std::string getPolicyId() const; + void setPolicyId(const std::string &policyId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + int getPageSize() const; + void setPageSize(int pageSize); + +private: + std::string filterValue_; + int pageNumber_; + std::string filterKey_; + std::string policyId_; + std::string regionId_; + int pageSize_; +}; +} // namespace Model +} // namespace DBFS +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYAPPLIEDDBFSREQUEST_H_ diff --git a/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyAppliedDbfsResult.h b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyAppliedDbfsResult.h new file mode 100644 index 000000000..76f6cc61e --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyAppliedDbfsResult.h @@ -0,0 +1,67 @@ +/* + * 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_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYAPPLIEDDBFSRESULT_H_ +#define ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYAPPLIEDDBFSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DBFS + { + namespace Model + { + class ALIBABACLOUD_DBFS_EXPORT ListAutoSnapshotPolicyAppliedDbfsResult : public ServiceResult + { + public: + struct DbfsListItem + { + std::string status; + std::string snapshotCount; + std::string fsName; + long sizeG; + std::string fsId; + std::string regionId; + std::string totalSize; + }; + + + ListAutoSnapshotPolicyAppliedDbfsResult(); + explicit ListAutoSnapshotPolicyAppliedDbfsResult(const std::string &payload); + ~ListAutoSnapshotPolicyAppliedDbfsResult(); + std::vector getDbfsList()const; + int getTotalCount()const; + int getPageSize()const; + int getPageNumber()const; + + protected: + void parse(const std::string &payload); + private: + std::vector dbfsList_; + int totalCount_; + int pageSize_; + int pageNumber_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYAPPLIEDDBFSRESULT_H_ \ No newline at end of file diff --git a/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyUnappliedDbfsRequest.h b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyUnappliedDbfsRequest.h new file mode 100644 index 000000000..e358c1e09 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyUnappliedDbfsRequest.h @@ -0,0 +1,54 @@ +/* + * 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_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYUNAPPLIEDDBFSREQUEST_H_ +#define ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYUNAPPLIEDDBFSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace DBFS { +namespace Model { +class ALIBABACLOUD_DBFS_EXPORT ListAutoSnapshotPolicyUnappliedDbfsRequest : public RpcServiceRequest { +public: + ListAutoSnapshotPolicyUnappliedDbfsRequest(); + ~ListAutoSnapshotPolicyUnappliedDbfsRequest(); + std::string getFilterValue() const; + void setFilterValue(const std::string &filterValue); + int getPageNumber() const; + void setPageNumber(int pageNumber); + std::string getFilterKey() const; + void setFilterKey(const std::string &filterKey); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + int getPageSize() const; + void setPageSize(int pageSize); + +private: + std::string filterValue_; + int pageNumber_; + std::string filterKey_; + std::string regionId_; + int pageSize_; +}; +} // namespace Model +} // namespace DBFS +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYUNAPPLIEDDBFSREQUEST_H_ diff --git a/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyUnappliedDbfsResult.h b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyUnappliedDbfsResult.h new file mode 100644 index 000000000..28a693dab --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ListAutoSnapshotPolicyUnappliedDbfsResult.h @@ -0,0 +1,67 @@ +/* + * 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_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYUNAPPLIEDDBFSRESULT_H_ +#define ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYUNAPPLIEDDBFSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DBFS + { + namespace Model + { + class ALIBABACLOUD_DBFS_EXPORT ListAutoSnapshotPolicyUnappliedDbfsResult : public ServiceResult + { + public: + struct DbfsListItem + { + std::string status; + std::string snapshotCount; + std::string fsName; + long sizeG; + std::string fsId; + std::string regionId; + long totalSize; + }; + + + ListAutoSnapshotPolicyUnappliedDbfsResult(); + explicit ListAutoSnapshotPolicyUnappliedDbfsResult(const std::string &payload); + ~ListAutoSnapshotPolicyUnappliedDbfsResult(); + std::vector getDbfsList()const; + int getTotalCount()const; + int getPageSize()const; + int getPageNumber()const; + + protected: + void parse(const std::string &payload); + private: + std::vector dbfsList_; + int totalCount_; + int pageSize_; + int pageNumber_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DBFS_MODEL_LISTAUTOSNAPSHOTPOLICYUNAPPLIEDDBFSRESULT_H_ \ No newline at end of file diff --git a/dbfs/include/alibabacloud/dbfs/model/ListDbfsResult.h b/dbfs/include/alibabacloud/dbfs/model/ListDbfsResult.h index cad08eb9f..cdbb14503 100644 --- a/dbfs/include/alibabacloud/dbfs/model/ListDbfsResult.h +++ b/dbfs/include/alibabacloud/dbfs/model/ListDbfsResult.h @@ -34,6 +34,13 @@ namespace AlibabaCloud public: struct Info { + struct SnapshotInfo + { + int snapshotCount; + long totalSize; + std::string linkId; + std::string policyId; + }; struct TagList { std::string tagKey; @@ -49,30 +56,31 @@ namespace AlibabaCloud int sizeG; std::string ebsId; }; - std::string status; - std::string lastFailed; std::string category; std::string createdTime; std::string kMSKeyId; - std::string zoneId; - bool enableRaid; std::vector ecsList; int sizeG; - std::string performanceLevel; std::string fsId; std::string dBFSClusterId; bool encryption; - std::string payType; std::string lastUmountTime; - std::string fsName; std::vector ebsList; - std::string usedScene; int raidStrip; std::string lastMountTime; - std::string regionId; - int attachNodeNumber; std::string instanceType; std::vector tags; + std::string status; + std::string lastFailed; + std::string zoneId; + bool enableRaid; + std::string performanceLevel; + std::string payType; + SnapshotInfo snapshotInfo; + std::string fsName; + std::string usedScene; + std::string regionId; + int attachNodeNumber; }; diff --git a/dbfs/include/alibabacloud/dbfs/model/ModifyAutoSnapshotPolicyRequest.h b/dbfs/include/alibabacloud/dbfs/model/ModifyAutoSnapshotPolicyRequest.h new file mode 100644 index 000000000..03d254d04 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ModifyAutoSnapshotPolicyRequest.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_DBFS_MODEL_MODIFYAUTOSNAPSHOTPOLICYREQUEST_H_ +#define ALIBABACLOUD_DBFS_MODEL_MODIFYAUTOSNAPSHOTPOLICYREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace DBFS { +namespace Model { +class ALIBABACLOUD_DBFS_EXPORT ModifyAutoSnapshotPolicyRequest : public RpcServiceRequest { +public: + ModifyAutoSnapshotPolicyRequest(); + ~ModifyAutoSnapshotPolicyRequest(); + std::vector getTimePoints() const; + void setTimePoints(const std::vector &timePoints); + std::vector getRepeatWeekdays() const; + void setRepeatWeekdays(const std::vector &repeatWeekdays); + std::string getPolicyId() const; + void setPolicyId(const std::string &policyId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getPolicyName() const; + void setPolicyName(const std::string &policyName); + int getRetentionDays() const; + void setRetentionDays(int retentionDays); + +private: + std::vector timePoints_; + std::vector repeatWeekdays_; + std::string policyId_; + std::string regionId_; + std::string policyName_; + int retentionDays_; +}; +} // namespace Model +} // namespace DBFS +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DBFS_MODEL_MODIFYAUTOSNAPSHOTPOLICYREQUEST_H_ diff --git a/dbfs/include/alibabacloud/dbfs/model/ModifyAutoSnapshotPolicyResult.h b/dbfs/include/alibabacloud/dbfs/model/ModifyAutoSnapshotPolicyResult.h new file mode 100644 index 000000000..a4a94df86 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ModifyAutoSnapshotPolicyResult.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_DBFS_MODEL_MODIFYAUTOSNAPSHOTPOLICYRESULT_H_ +#define ALIBABACLOUD_DBFS_MODEL_MODIFYAUTOSNAPSHOTPOLICYRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DBFS + { + namespace Model + { + class ALIBABACLOUD_DBFS_EXPORT ModifyAutoSnapshotPolicyResult : public ServiceResult + { + public: + + + ModifyAutoSnapshotPolicyResult(); + explicit ModifyAutoSnapshotPolicyResult(const std::string &payload); + ~ModifyAutoSnapshotPolicyResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_DBFS_MODEL_MODIFYAUTOSNAPSHOTPOLICYRESULT_H_ \ No newline at end of file diff --git a/dbfs/include/alibabacloud/dbfs/model/ModifySnapshotAttributeRequest.h b/dbfs/include/alibabacloud/dbfs/model/ModifySnapshotAttributeRequest.h new file mode 100644 index 000000000..be408e050 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ModifySnapshotAttributeRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DBFS_MODEL_MODIFYSNAPSHOTATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_DBFS_MODEL_MODIFYSNAPSHOTATTRIBUTEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace DBFS { +namespace Model { +class ALIBABACLOUD_DBFS_EXPORT ModifySnapshotAttributeRequest : public RpcServiceRequest { +public: + ModifySnapshotAttributeRequest(); + ~ModifySnapshotAttributeRequest(); + std::string getSnapshotId() const; + void setSnapshotId(const std::string &snapshotId); + std::string getDescription() const; + void setDescription(const std::string &description); + std::string getSnapshotName() const; + void setSnapshotName(const std::string &snapshotName); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + +private: + std::string snapshotId_; + std::string description_; + std::string snapshotName_; + std::string regionId_; +}; +} // namespace Model +} // namespace DBFS +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DBFS_MODEL_MODIFYSNAPSHOTATTRIBUTEREQUEST_H_ diff --git a/dbfs/include/alibabacloud/dbfs/model/ModifySnapshotAttributeResult.h b/dbfs/include/alibabacloud/dbfs/model/ModifySnapshotAttributeResult.h new file mode 100644 index 000000000..d62ba5b70 --- /dev/null +++ b/dbfs/include/alibabacloud/dbfs/model/ModifySnapshotAttributeResult.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_DBFS_MODEL_MODIFYSNAPSHOTATTRIBUTERESULT_H_ +#define ALIBABACLOUD_DBFS_MODEL_MODIFYSNAPSHOTATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DBFS + { + namespace Model + { + class ALIBABACLOUD_DBFS_EXPORT ModifySnapshotAttributeResult : public ServiceResult + { + public: + + + ModifySnapshotAttributeResult(); + explicit ModifySnapshotAttributeResult(const std::string &payload); + ~ModifySnapshotAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_DBFS_MODEL_MODIFYSNAPSHOTATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/dbfs/src/DBFSClient.cc b/dbfs/src/DBFSClient.cc index 8a03e9406..59502e92a 100644 --- a/dbfs/src/DBFSClient.cc +++ b/dbfs/src/DBFSClient.cc @@ -87,6 +87,42 @@ DBFSClient::AddTagsBatchOutcomeCallable DBFSClient::addTagsBatchCallable(const A return task->get_future(); } +DBFSClient::ApplyAutoSnapshotPolicyOutcome DBFSClient::applyAutoSnapshotPolicy(const ApplyAutoSnapshotPolicyRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ApplyAutoSnapshotPolicyOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ApplyAutoSnapshotPolicyOutcome(ApplyAutoSnapshotPolicyResult(outcome.result())); + else + return ApplyAutoSnapshotPolicyOutcome(outcome.error()); +} + +void DBFSClient::applyAutoSnapshotPolicyAsync(const ApplyAutoSnapshotPolicyRequest& request, const ApplyAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, applyAutoSnapshotPolicy(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DBFSClient::ApplyAutoSnapshotPolicyOutcomeCallable DBFSClient::applyAutoSnapshotPolicyCallable(const ApplyAutoSnapshotPolicyRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->applyAutoSnapshotPolicy(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + DBFSClient::AttachDbfsOutcome DBFSClient::attachDbfs(const AttachDbfsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -303,6 +339,42 @@ DBFSClient::CreateSnapshotOutcomeCallable DBFSClient::createSnapshotCallable(con return task->get_future(); } +DBFSClient::DeleteAutoSnapshotPolicyOutcome DBFSClient::deleteAutoSnapshotPolicy(const DeleteAutoSnapshotPolicyRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteAutoSnapshotPolicyOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteAutoSnapshotPolicyOutcome(DeleteAutoSnapshotPolicyResult(outcome.result())); + else + return DeleteAutoSnapshotPolicyOutcome(outcome.error()); +} + +void DBFSClient::deleteAutoSnapshotPolicyAsync(const DeleteAutoSnapshotPolicyRequest& request, const DeleteAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteAutoSnapshotPolicy(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DBFSClient::DeleteAutoSnapshotPolicyOutcomeCallable DBFSClient::deleteAutoSnapshotPolicyCallable(const DeleteAutoSnapshotPolicyRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteAutoSnapshotPolicy(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + DBFSClient::DeleteDbfsOutcome DBFSClient::deleteDbfs(const DeleteDbfsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -519,6 +591,42 @@ DBFSClient::DetachDbfsOutcomeCallable DBFSClient::detachDbfsCallable(const Detac return task->get_future(); } +DBFSClient::GetAutoSnapshotPolicyOutcome DBFSClient::getAutoSnapshotPolicy(const GetAutoSnapshotPolicyRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetAutoSnapshotPolicyOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetAutoSnapshotPolicyOutcome(GetAutoSnapshotPolicyResult(outcome.result())); + else + return GetAutoSnapshotPolicyOutcome(outcome.error()); +} + +void DBFSClient::getAutoSnapshotPolicyAsync(const GetAutoSnapshotPolicyRequest& request, const GetAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getAutoSnapshotPolicy(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DBFSClient::GetAutoSnapshotPolicyOutcomeCallable DBFSClient::getAutoSnapshotPolicyCallable(const GetAutoSnapshotPolicyRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getAutoSnapshotPolicy(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + DBFSClient::GetDbfsOutcome DBFSClient::getDbfs(const GetDbfsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -591,6 +699,114 @@ DBFSClient::GetServiceLinkedRoleOutcomeCallable DBFSClient::getServiceLinkedRole return task->get_future(); } +DBFSClient::ListAutoSnapshotPoliciesOutcome DBFSClient::listAutoSnapshotPolicies(const ListAutoSnapshotPoliciesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAutoSnapshotPoliciesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAutoSnapshotPoliciesOutcome(ListAutoSnapshotPoliciesResult(outcome.result())); + else + return ListAutoSnapshotPoliciesOutcome(outcome.error()); +} + +void DBFSClient::listAutoSnapshotPoliciesAsync(const ListAutoSnapshotPoliciesRequest& request, const ListAutoSnapshotPoliciesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAutoSnapshotPolicies(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DBFSClient::ListAutoSnapshotPoliciesOutcomeCallable DBFSClient::listAutoSnapshotPoliciesCallable(const ListAutoSnapshotPoliciesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAutoSnapshotPolicies(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DBFSClient::ListAutoSnapshotPolicyAppliedDbfsOutcome DBFSClient::listAutoSnapshotPolicyAppliedDbfs(const ListAutoSnapshotPolicyAppliedDbfsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAutoSnapshotPolicyAppliedDbfsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAutoSnapshotPolicyAppliedDbfsOutcome(ListAutoSnapshotPolicyAppliedDbfsResult(outcome.result())); + else + return ListAutoSnapshotPolicyAppliedDbfsOutcome(outcome.error()); +} + +void DBFSClient::listAutoSnapshotPolicyAppliedDbfsAsync(const ListAutoSnapshotPolicyAppliedDbfsRequest& request, const ListAutoSnapshotPolicyAppliedDbfsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAutoSnapshotPolicyAppliedDbfs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DBFSClient::ListAutoSnapshotPolicyAppliedDbfsOutcomeCallable DBFSClient::listAutoSnapshotPolicyAppliedDbfsCallable(const ListAutoSnapshotPolicyAppliedDbfsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAutoSnapshotPolicyAppliedDbfs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DBFSClient::ListAutoSnapshotPolicyUnappliedDbfsOutcome DBFSClient::listAutoSnapshotPolicyUnappliedDbfs(const ListAutoSnapshotPolicyUnappliedDbfsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAutoSnapshotPolicyUnappliedDbfsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAutoSnapshotPolicyUnappliedDbfsOutcome(ListAutoSnapshotPolicyUnappliedDbfsResult(outcome.result())); + else + return ListAutoSnapshotPolicyUnappliedDbfsOutcome(outcome.error()); +} + +void DBFSClient::listAutoSnapshotPolicyUnappliedDbfsAsync(const ListAutoSnapshotPolicyUnappliedDbfsRequest& request, const ListAutoSnapshotPolicyUnappliedDbfsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAutoSnapshotPolicyUnappliedDbfs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DBFSClient::ListAutoSnapshotPolicyUnappliedDbfsOutcomeCallable DBFSClient::listAutoSnapshotPolicyUnappliedDbfsCallable(const ListAutoSnapshotPolicyUnappliedDbfsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAutoSnapshotPolicyUnappliedDbfs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + DBFSClient::ListDbfsOutcome DBFSClient::listDbfs(const ListDbfsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -807,6 +1023,78 @@ DBFSClient::ListTagValuesOutcomeCallable DBFSClient::listTagValuesCallable(const return task->get_future(); } +DBFSClient::ModifyAutoSnapshotPolicyOutcome DBFSClient::modifyAutoSnapshotPolicy(const ModifyAutoSnapshotPolicyRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyAutoSnapshotPolicyOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyAutoSnapshotPolicyOutcome(ModifyAutoSnapshotPolicyResult(outcome.result())); + else + return ModifyAutoSnapshotPolicyOutcome(outcome.error()); +} + +void DBFSClient::modifyAutoSnapshotPolicyAsync(const ModifyAutoSnapshotPolicyRequest& request, const ModifyAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyAutoSnapshotPolicy(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DBFSClient::ModifyAutoSnapshotPolicyOutcomeCallable DBFSClient::modifyAutoSnapshotPolicyCallable(const ModifyAutoSnapshotPolicyRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyAutoSnapshotPolicy(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DBFSClient::ModifySnapshotAttributeOutcome DBFSClient::modifySnapshotAttribute(const ModifySnapshotAttributeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifySnapshotAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifySnapshotAttributeOutcome(ModifySnapshotAttributeResult(outcome.result())); + else + return ModifySnapshotAttributeOutcome(outcome.error()); +} + +void DBFSClient::modifySnapshotAttributeAsync(const ModifySnapshotAttributeRequest& request, const ModifySnapshotAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifySnapshotAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DBFSClient::ModifySnapshotAttributeOutcomeCallable DBFSClient::modifySnapshotAttributeCallable(const ModifySnapshotAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifySnapshotAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + DBFSClient::RenameDbfsOutcome DBFSClient::renameDbfs(const RenameDbfsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/dbfs/src/model/ApplyAutoSnapshotPolicyRequest.cc b/dbfs/src/model/ApplyAutoSnapshotPolicyRequest.cc new file mode 100644 index 000000000..fe7fe234b --- /dev/null +++ b/dbfs/src/model/ApplyAutoSnapshotPolicyRequest.cc @@ -0,0 +1,56 @@ +/* + * 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::DBFS::Model::ApplyAutoSnapshotPolicyRequest; + +ApplyAutoSnapshotPolicyRequest::ApplyAutoSnapshotPolicyRequest() + : RpcServiceRequest("dbfs", "2020-04-18", "ApplyAutoSnapshotPolicy") { + setMethod(HttpRequest::Method::Post); +} + +ApplyAutoSnapshotPolicyRequest::~ApplyAutoSnapshotPolicyRequest() {} + +std::vector ApplyAutoSnapshotPolicyRequest::getDbfsIds() const { + return dbfsIds_; +} + +void ApplyAutoSnapshotPolicyRequest::setDbfsIds(const std::vector &dbfsIds) { + dbfsIds_ = dbfsIds; + for(int dep1 = 0; dep1 != dbfsIds.size(); dep1++) { + setParameter(std::string("DbfsIds") + "." + std::to_string(dep1 + 1), dbfsIds[dep1]); + } +} + +std::string ApplyAutoSnapshotPolicyRequest::getPolicyId() const { + return policyId_; +} + +void ApplyAutoSnapshotPolicyRequest::setPolicyId(const std::string &policyId) { + policyId_ = policyId; + setParameter(std::string("PolicyId"), policyId); +} + +std::string ApplyAutoSnapshotPolicyRequest::getRegionId() const { + return regionId_; +} + +void ApplyAutoSnapshotPolicyRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + diff --git a/dbfs/src/model/ApplyAutoSnapshotPolicyResult.cc b/dbfs/src/model/ApplyAutoSnapshotPolicyResult.cc new file mode 100644 index 000000000..be5fe62bb --- /dev/null +++ b/dbfs/src/model/ApplyAutoSnapshotPolicyResult.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::DBFS; +using namespace AlibabaCloud::DBFS::Model; + +ApplyAutoSnapshotPolicyResult::ApplyAutoSnapshotPolicyResult() : + ServiceResult() +{} + +ApplyAutoSnapshotPolicyResult::ApplyAutoSnapshotPolicyResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ApplyAutoSnapshotPolicyResult::~ApplyAutoSnapshotPolicyResult() +{} + +void ApplyAutoSnapshotPolicyResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/dbfs/src/model/DeleteAutoSnapshotPolicyRequest.cc b/dbfs/src/model/DeleteAutoSnapshotPolicyRequest.cc new file mode 100644 index 000000000..21cce3fa7 --- /dev/null +++ b/dbfs/src/model/DeleteAutoSnapshotPolicyRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::DBFS::Model::DeleteAutoSnapshotPolicyRequest; + +DeleteAutoSnapshotPolicyRequest::DeleteAutoSnapshotPolicyRequest() + : RpcServiceRequest("dbfs", "2020-04-18", "DeleteAutoSnapshotPolicy") { + setMethod(HttpRequest::Method::Post); +} + +DeleteAutoSnapshotPolicyRequest::~DeleteAutoSnapshotPolicyRequest() {} + +std::string DeleteAutoSnapshotPolicyRequest::getPolicyId() const { + return policyId_; +} + +void DeleteAutoSnapshotPolicyRequest::setPolicyId(const std::string &policyId) { + policyId_ = policyId; + setParameter(std::string("PolicyId"), policyId); +} + +std::string DeleteAutoSnapshotPolicyRequest::getRegionId() const { + return regionId_; +} + +void DeleteAutoSnapshotPolicyRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + diff --git a/dbfs/src/model/DeleteAutoSnapshotPolicyResult.cc b/dbfs/src/model/DeleteAutoSnapshotPolicyResult.cc new file mode 100644 index 000000000..b8ebcd6c8 --- /dev/null +++ b/dbfs/src/model/DeleteAutoSnapshotPolicyResult.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::DBFS; +using namespace AlibabaCloud::DBFS::Model; + +DeleteAutoSnapshotPolicyResult::DeleteAutoSnapshotPolicyResult() : + ServiceResult() +{} + +DeleteAutoSnapshotPolicyResult::DeleteAutoSnapshotPolicyResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteAutoSnapshotPolicyResult::~DeleteAutoSnapshotPolicyResult() +{} + +void DeleteAutoSnapshotPolicyResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/dbfs/src/model/GetAutoSnapshotPolicyRequest.cc b/dbfs/src/model/GetAutoSnapshotPolicyRequest.cc new file mode 100644 index 000000000..1453bbe4d --- /dev/null +++ b/dbfs/src/model/GetAutoSnapshotPolicyRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::DBFS::Model::GetAutoSnapshotPolicyRequest; + +GetAutoSnapshotPolicyRequest::GetAutoSnapshotPolicyRequest() + : RpcServiceRequest("dbfs", "2020-04-18", "GetAutoSnapshotPolicy") { + setMethod(HttpRequest::Method::Post); +} + +GetAutoSnapshotPolicyRequest::~GetAutoSnapshotPolicyRequest() {} + +std::string GetAutoSnapshotPolicyRequest::getPolicyId() const { + return policyId_; +} + +void GetAutoSnapshotPolicyRequest::setPolicyId(const std::string &policyId) { + policyId_ = policyId; + setParameter(std::string("PolicyId"), policyId); +} + +std::string GetAutoSnapshotPolicyRequest::getRegionId() const { + return regionId_; +} + +void GetAutoSnapshotPolicyRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + diff --git a/dbfs/src/model/GetAutoSnapshotPolicyResult.cc b/dbfs/src/model/GetAutoSnapshotPolicyResult.cc new file mode 100644 index 000000000..4fd3acbe4 --- /dev/null +++ b/dbfs/src/model/GetAutoSnapshotPolicyResult.cc @@ -0,0 +1,76 @@ +/* + * 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::DBFS; +using namespace AlibabaCloud::DBFS::Model; + +GetAutoSnapshotPolicyResult::GetAutoSnapshotPolicyResult() : + ServiceResult() +{} + +GetAutoSnapshotPolicyResult::GetAutoSnapshotPolicyResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetAutoSnapshotPolicyResult::~GetAutoSnapshotPolicyResult() +{} + +void GetAutoSnapshotPolicyResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["PolicyId"].isNull()) + data_.policyId = dataNode["PolicyId"].asString(); + if(!dataNode["PolicyName"].isNull()) + data_.policyName = dataNode["PolicyName"].asString(); + if(!dataNode["AccountId"].isNull()) + data_.accountId = dataNode["AccountId"].asString(); + if(!dataNode["RegionId"].isNull()) + data_.regionId = dataNode["RegionId"].asString(); + if(!dataNode["Status"].isNull()) + data_.status = dataNode["Status"].asString(); + if(!dataNode["StatusDetail"].isNull()) + data_.statusDetail = dataNode["StatusDetail"].asString(); + if(!dataNode["RetentionDays"].isNull()) + data_.retentionDays = std::stoi(dataNode["RetentionDays"].asString()); + if(!dataNode["AppliedDbfsNumber"].isNull()) + data_.appliedDbfsNumber = std::stoi(dataNode["AppliedDbfsNumber"].asString()); + if(!dataNode["CreatedTime"].isNull()) + data_.createdTime = dataNode["CreatedTime"].asString(); + if(!dataNode["LastModified"].isNull()) + data_.lastModified = dataNode["LastModified"].asString(); + auto allRepeatWeekdays = dataNode["RepeatWeekdays"]["RepeatWeekdays"]; + for (auto value : allRepeatWeekdays) + data_.repeatWeekdays.push_back(value.asString()); + auto allTimePoints = dataNode["TimePoints"]["TimePoints"]; + for (auto value : allTimePoints) + data_.timePoints.push_back(value.asString()); + +} + +GetAutoSnapshotPolicyResult::Data GetAutoSnapshotPolicyResult::getData()const +{ + return data_; +} + diff --git a/dbfs/src/model/GetDbfsResult.cc b/dbfs/src/model/GetDbfsResult.cc index 6304d6419..4f14fdb00 100644 --- a/dbfs/src/model/GetDbfsResult.cc +++ b/dbfs/src/model/GetDbfsResult.cc @@ -114,6 +114,15 @@ void GetDbfsResult::parse(const std::string &payload) ebsListItemObject.sizeG = std::stoi(dBFSInfoNodeEbsListEbsListItem["SizeG"].asString()); dBFSInfo_.ebsList.push_back(ebsListItemObject); } + auto snapshotInfoNode = dBFSInfoNode["SnapshotInfo"]; + if(!snapshotInfoNode["SnapshotCount"].isNull()) + dBFSInfo_.snapshotInfo.snapshotCount = std::stoi(snapshotInfoNode["SnapshotCount"].asString()); + if(!snapshotInfoNode["LinkId"].isNull()) + dBFSInfo_.snapshotInfo.linkId = snapshotInfoNode["LinkId"].asString(); + if(!snapshotInfoNode["totalSize"].isNull()) + dBFSInfo_.snapshotInfo.totalSize = std::stol(snapshotInfoNode["totalSize"].asString()); + if(!snapshotInfoNode["PolicyId"].isNull()) + dBFSInfo_.snapshotInfo.policyId = snapshotInfoNode["PolicyId"].asString(); } diff --git a/dbfs/src/model/ListAutoSnapshotPoliciesRequest.cc b/dbfs/src/model/ListAutoSnapshotPoliciesRequest.cc new file mode 100644 index 000000000..7896d743e --- /dev/null +++ b/dbfs/src/model/ListAutoSnapshotPoliciesRequest.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 + +using AlibabaCloud::DBFS::Model::ListAutoSnapshotPoliciesRequest; + +ListAutoSnapshotPoliciesRequest::ListAutoSnapshotPoliciesRequest() + : RpcServiceRequest("dbfs", "2020-04-18", "ListAutoSnapshotPolicies") { + setMethod(HttpRequest::Method::Post); +} + +ListAutoSnapshotPoliciesRequest::~ListAutoSnapshotPoliciesRequest() {} + +std::string ListAutoSnapshotPoliciesRequest::getFilterValue() const { + return filterValue_; +} + +void ListAutoSnapshotPoliciesRequest::setFilterValue(const std::string &filterValue) { + filterValue_ = filterValue; + setParameter(std::string("FilterValue"), filterValue); +} + +int ListAutoSnapshotPoliciesRequest::getPageNumber() const { + return pageNumber_; +} + +void ListAutoSnapshotPoliciesRequest::setPageNumber(int pageNumber) { + pageNumber_ = pageNumber; + setParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +std::string ListAutoSnapshotPoliciesRequest::getFilterKey() const { + return filterKey_; +} + +void ListAutoSnapshotPoliciesRequest::setFilterKey(const std::string &filterKey) { + filterKey_ = filterKey; + setParameter(std::string("FilterKey"), filterKey); +} + +std::string ListAutoSnapshotPoliciesRequest::getRegionId() const { + return regionId_; +} + +void ListAutoSnapshotPoliciesRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +int ListAutoSnapshotPoliciesRequest::getPageSize() const { + return pageSize_; +} + +void ListAutoSnapshotPoliciesRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + diff --git a/dbfs/src/model/ListAutoSnapshotPoliciesResult.cc b/dbfs/src/model/ListAutoSnapshotPoliciesResult.cc new file mode 100644 index 000000000..06ea5fe19 --- /dev/null +++ b/dbfs/src/model/ListAutoSnapshotPoliciesResult.cc @@ -0,0 +1,102 @@ +/* + * 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::DBFS; +using namespace AlibabaCloud::DBFS::Model; + +ListAutoSnapshotPoliciesResult::ListAutoSnapshotPoliciesResult() : + ServiceResult() +{} + +ListAutoSnapshotPoliciesResult::ListAutoSnapshotPoliciesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAutoSnapshotPoliciesResult::~ListAutoSnapshotPoliciesResult() +{} + +void ListAutoSnapshotPoliciesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allSnapshotPoliciesNode = value["SnapshotPolicies"]["SnapshotPoliciesItem"]; + for (auto valueSnapshotPoliciesSnapshotPoliciesItem : allSnapshotPoliciesNode) + { + SnapshotPoliciesItem snapshotPoliciesObject; + if(!valueSnapshotPoliciesSnapshotPoliciesItem["PolicyId"].isNull()) + snapshotPoliciesObject.policyId = valueSnapshotPoliciesSnapshotPoliciesItem["PolicyId"].asString(); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["PolicyName"].isNull()) + snapshotPoliciesObject.policyName = valueSnapshotPoliciesSnapshotPoliciesItem["PolicyName"].asString(); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["AccountId"].isNull()) + snapshotPoliciesObject.accountId = valueSnapshotPoliciesSnapshotPoliciesItem["AccountId"].asString(); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["RegionId"].isNull()) + snapshotPoliciesObject.regionId = valueSnapshotPoliciesSnapshotPoliciesItem["RegionId"].asString(); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["Status"].isNull()) + snapshotPoliciesObject.status = valueSnapshotPoliciesSnapshotPoliciesItem["Status"].asString(); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["StatusDetail"].isNull()) + snapshotPoliciesObject.statusDetail = valueSnapshotPoliciesSnapshotPoliciesItem["StatusDetail"].asString(); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["RetentionDays"].isNull()) + snapshotPoliciesObject.retentionDays = std::stoi(valueSnapshotPoliciesSnapshotPoliciesItem["RetentionDays"].asString()); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["AppliedDbfsNumber"].isNull()) + snapshotPoliciesObject.appliedDbfsNumber = std::stoi(valueSnapshotPoliciesSnapshotPoliciesItem["AppliedDbfsNumber"].asString()); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["CreatedTime"].isNull()) + snapshotPoliciesObject.createdTime = valueSnapshotPoliciesSnapshotPoliciesItem["CreatedTime"].asString(); + if(!valueSnapshotPoliciesSnapshotPoliciesItem["LastModified"].isNull()) + snapshotPoliciesObject.lastModified = valueSnapshotPoliciesSnapshotPoliciesItem["LastModified"].asString(); + auto allRepeatWeekdays = value["RepeatWeekdays"]["RepeatWeekdays"]; + for (auto value : allRepeatWeekdays) + snapshotPoliciesObject.repeatWeekdays.push_back(value.asString()); + auto allTimePoints = value["TimePoints"]["TimePoints"]; + for (auto value : allTimePoints) + snapshotPoliciesObject.timePoints.push_back(value.asString()); + snapshotPolicies_.push_back(snapshotPoliciesObject); + } + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); + +} + +int ListAutoSnapshotPoliciesResult::getTotalCount()const +{ + return totalCount_; +} + +int ListAutoSnapshotPoliciesResult::getPageSize()const +{ + return pageSize_; +} + +int ListAutoSnapshotPoliciesResult::getPageNumber()const +{ + return pageNumber_; +} + +std::vector ListAutoSnapshotPoliciesResult::getSnapshotPolicies()const +{ + return snapshotPolicies_; +} + diff --git a/dbfs/src/model/ListAutoSnapshotPolicyAppliedDbfsRequest.cc b/dbfs/src/model/ListAutoSnapshotPolicyAppliedDbfsRequest.cc new file mode 100644 index 000000000..5c732f822 --- /dev/null +++ b/dbfs/src/model/ListAutoSnapshotPolicyAppliedDbfsRequest.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::DBFS::Model::ListAutoSnapshotPolicyAppliedDbfsRequest; + +ListAutoSnapshotPolicyAppliedDbfsRequest::ListAutoSnapshotPolicyAppliedDbfsRequest() + : RpcServiceRequest("dbfs", "2020-04-18", "ListAutoSnapshotPolicyAppliedDbfs") { + setMethod(HttpRequest::Method::Post); +} + +ListAutoSnapshotPolicyAppliedDbfsRequest::~ListAutoSnapshotPolicyAppliedDbfsRequest() {} + +std::string ListAutoSnapshotPolicyAppliedDbfsRequest::getFilterValue() const { + return filterValue_; +} + +void ListAutoSnapshotPolicyAppliedDbfsRequest::setFilterValue(const std::string &filterValue) { + filterValue_ = filterValue; + setParameter(std::string("FilterValue"), filterValue); +} + +int ListAutoSnapshotPolicyAppliedDbfsRequest::getPageNumber() const { + return pageNumber_; +} + +void ListAutoSnapshotPolicyAppliedDbfsRequest::setPageNumber(int pageNumber) { + pageNumber_ = pageNumber; + setParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +std::string ListAutoSnapshotPolicyAppliedDbfsRequest::getFilterKey() const { + return filterKey_; +} + +void ListAutoSnapshotPolicyAppliedDbfsRequest::setFilterKey(const std::string &filterKey) { + filterKey_ = filterKey; + setParameter(std::string("FilterKey"), filterKey); +} + +std::string ListAutoSnapshotPolicyAppliedDbfsRequest::getPolicyId() const { + return policyId_; +} + +void ListAutoSnapshotPolicyAppliedDbfsRequest::setPolicyId(const std::string &policyId) { + policyId_ = policyId; + setParameter(std::string("PolicyId"), policyId); +} + +std::string ListAutoSnapshotPolicyAppliedDbfsRequest::getRegionId() const { + return regionId_; +} + +void ListAutoSnapshotPolicyAppliedDbfsRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +int ListAutoSnapshotPolicyAppliedDbfsRequest::getPageSize() const { + return pageSize_; +} + +void ListAutoSnapshotPolicyAppliedDbfsRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + diff --git a/dbfs/src/model/ListAutoSnapshotPolicyAppliedDbfsResult.cc b/dbfs/src/model/ListAutoSnapshotPolicyAppliedDbfsResult.cc new file mode 100644 index 000000000..e3d053829 --- /dev/null +++ b/dbfs/src/model/ListAutoSnapshotPolicyAppliedDbfsResult.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 +#include + +using namespace AlibabaCloud::DBFS; +using namespace AlibabaCloud::DBFS::Model; + +ListAutoSnapshotPolicyAppliedDbfsResult::ListAutoSnapshotPolicyAppliedDbfsResult() : + ServiceResult() +{} + +ListAutoSnapshotPolicyAppliedDbfsResult::ListAutoSnapshotPolicyAppliedDbfsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAutoSnapshotPolicyAppliedDbfsResult::~ListAutoSnapshotPolicyAppliedDbfsResult() +{} + +void ListAutoSnapshotPolicyAppliedDbfsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allDbfsListNode = value["DbfsList"]["DbfsListItem"]; + for (auto valueDbfsListDbfsListItem : allDbfsListNode) + { + DbfsListItem dbfsListObject; + if(!valueDbfsListDbfsListItem["FsId"].isNull()) + dbfsListObject.fsId = valueDbfsListDbfsListItem["FsId"].asString(); + if(!valueDbfsListDbfsListItem["FsName"].isNull()) + dbfsListObject.fsName = valueDbfsListDbfsListItem["FsName"].asString(); + if(!valueDbfsListDbfsListItem["Status"].isNull()) + dbfsListObject.status = valueDbfsListDbfsListItem["Status"].asString(); + if(!valueDbfsListDbfsListItem["SizeG"].isNull()) + dbfsListObject.sizeG = std::stol(valueDbfsListDbfsListItem["SizeG"].asString()); + if(!valueDbfsListDbfsListItem["RegionId"].isNull()) + dbfsListObject.regionId = valueDbfsListDbfsListItem["RegionId"].asString(); + if(!valueDbfsListDbfsListItem["SnapshotCount"].isNull()) + dbfsListObject.snapshotCount = valueDbfsListDbfsListItem["SnapshotCount"].asString(); + if(!valueDbfsListDbfsListItem["TotalSize"].isNull()) + dbfsListObject.totalSize = valueDbfsListDbfsListItem["TotalSize"].asString(); + dbfsList_.push_back(dbfsListObject); + } + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); + +} + +std::vector ListAutoSnapshotPolicyAppliedDbfsResult::getDbfsList()const +{ + return dbfsList_; +} + +int ListAutoSnapshotPolicyAppliedDbfsResult::getTotalCount()const +{ + return totalCount_; +} + +int ListAutoSnapshotPolicyAppliedDbfsResult::getPageSize()const +{ + return pageSize_; +} + +int ListAutoSnapshotPolicyAppliedDbfsResult::getPageNumber()const +{ + return pageNumber_; +} + diff --git a/dbfs/src/model/ListAutoSnapshotPolicyUnappliedDbfsRequest.cc b/dbfs/src/model/ListAutoSnapshotPolicyUnappliedDbfsRequest.cc new file mode 100644 index 000000000..ed4ab97db --- /dev/null +++ b/dbfs/src/model/ListAutoSnapshotPolicyUnappliedDbfsRequest.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 + +using AlibabaCloud::DBFS::Model::ListAutoSnapshotPolicyUnappliedDbfsRequest; + +ListAutoSnapshotPolicyUnappliedDbfsRequest::ListAutoSnapshotPolicyUnappliedDbfsRequest() + : RpcServiceRequest("dbfs", "2020-04-18", "ListAutoSnapshotPolicyUnappliedDbfs") { + setMethod(HttpRequest::Method::Post); +} + +ListAutoSnapshotPolicyUnappliedDbfsRequest::~ListAutoSnapshotPolicyUnappliedDbfsRequest() {} + +std::string ListAutoSnapshotPolicyUnappliedDbfsRequest::getFilterValue() const { + return filterValue_; +} + +void ListAutoSnapshotPolicyUnappliedDbfsRequest::setFilterValue(const std::string &filterValue) { + filterValue_ = filterValue; + setParameter(std::string("FilterValue"), filterValue); +} + +int ListAutoSnapshotPolicyUnappliedDbfsRequest::getPageNumber() const { + return pageNumber_; +} + +void ListAutoSnapshotPolicyUnappliedDbfsRequest::setPageNumber(int pageNumber) { + pageNumber_ = pageNumber; + setParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +std::string ListAutoSnapshotPolicyUnappliedDbfsRequest::getFilterKey() const { + return filterKey_; +} + +void ListAutoSnapshotPolicyUnappliedDbfsRequest::setFilterKey(const std::string &filterKey) { + filterKey_ = filterKey; + setParameter(std::string("FilterKey"), filterKey); +} + +std::string ListAutoSnapshotPolicyUnappliedDbfsRequest::getRegionId() const { + return regionId_; +} + +void ListAutoSnapshotPolicyUnappliedDbfsRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +int ListAutoSnapshotPolicyUnappliedDbfsRequest::getPageSize() const { + return pageSize_; +} + +void ListAutoSnapshotPolicyUnappliedDbfsRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + diff --git a/dbfs/src/model/ListAutoSnapshotPolicyUnappliedDbfsResult.cc b/dbfs/src/model/ListAutoSnapshotPolicyUnappliedDbfsResult.cc new file mode 100644 index 000000000..1532b22a6 --- /dev/null +++ b/dbfs/src/model/ListAutoSnapshotPolicyUnappliedDbfsResult.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 +#include + +using namespace AlibabaCloud::DBFS; +using namespace AlibabaCloud::DBFS::Model; + +ListAutoSnapshotPolicyUnappliedDbfsResult::ListAutoSnapshotPolicyUnappliedDbfsResult() : + ServiceResult() +{} + +ListAutoSnapshotPolicyUnappliedDbfsResult::ListAutoSnapshotPolicyUnappliedDbfsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAutoSnapshotPolicyUnappliedDbfsResult::~ListAutoSnapshotPolicyUnappliedDbfsResult() +{} + +void ListAutoSnapshotPolicyUnappliedDbfsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allDbfsListNode = value["DbfsList"]["DbfsListItem"]; + for (auto valueDbfsListDbfsListItem : allDbfsListNode) + { + DbfsListItem dbfsListObject; + if(!valueDbfsListDbfsListItem["FsId"].isNull()) + dbfsListObject.fsId = valueDbfsListDbfsListItem["FsId"].asString(); + if(!valueDbfsListDbfsListItem["FsName"].isNull()) + dbfsListObject.fsName = valueDbfsListDbfsListItem["FsName"].asString(); + if(!valueDbfsListDbfsListItem["Status"].isNull()) + dbfsListObject.status = valueDbfsListDbfsListItem["Status"].asString(); + if(!valueDbfsListDbfsListItem["SizeG"].isNull()) + dbfsListObject.sizeG = std::stol(valueDbfsListDbfsListItem["SizeG"].asString()); + if(!valueDbfsListDbfsListItem["RegionId"].isNull()) + dbfsListObject.regionId = valueDbfsListDbfsListItem["RegionId"].asString(); + if(!valueDbfsListDbfsListItem["SnapshotCount"].isNull()) + dbfsListObject.snapshotCount = valueDbfsListDbfsListItem["SnapshotCount"].asString(); + if(!valueDbfsListDbfsListItem["TotalSize"].isNull()) + dbfsListObject.totalSize = std::stol(valueDbfsListDbfsListItem["TotalSize"].asString()); + dbfsList_.push_back(dbfsListObject); + } + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); + +} + +std::vector ListAutoSnapshotPolicyUnappliedDbfsResult::getDbfsList()const +{ + return dbfsList_; +} + +int ListAutoSnapshotPolicyUnappliedDbfsResult::getTotalCount()const +{ + return totalCount_; +} + +int ListAutoSnapshotPolicyUnappliedDbfsResult::getPageSize()const +{ + return pageSize_; +} + +int ListAutoSnapshotPolicyUnappliedDbfsResult::getPageNumber()const +{ + return pageNumber_; +} + diff --git a/dbfs/src/model/ListDbfsResult.cc b/dbfs/src/model/ListDbfsResult.cc index a138b5cc1..628799965 100644 --- a/dbfs/src/model/ListDbfsResult.cc +++ b/dbfs/src/model/ListDbfsResult.cc @@ -115,6 +115,15 @@ void ListDbfsResult::parse(const std::string &payload) ebsListObject.sizeG = std::stoi(valueDBFSInfoInfoEbsListEbsListItem["SizeG"].asString()); dBFSInfoObject.ebsList.push_back(ebsListObject); } + auto snapshotInfoNode = value["SnapshotInfo"]; + if(!snapshotInfoNode["SnapshotCount"].isNull()) + dBFSInfoObject.snapshotInfo.snapshotCount = std::stoi(snapshotInfoNode["SnapshotCount"].asString()); + if(!snapshotInfoNode["TotalSize"].isNull()) + dBFSInfoObject.snapshotInfo.totalSize = std::stol(snapshotInfoNode["TotalSize"].asString()); + if(!snapshotInfoNode["LinkId"].isNull()) + dBFSInfoObject.snapshotInfo.linkId = snapshotInfoNode["LinkId"].asString(); + if(!snapshotInfoNode["PolicyId"].isNull()) + dBFSInfoObject.snapshotInfo.policyId = snapshotInfoNode["PolicyId"].asString(); dBFSInfo_.push_back(dBFSInfoObject); } if(!value["TotalCount"].isNull()) diff --git a/dbfs/src/model/ModifyAutoSnapshotPolicyRequest.cc b/dbfs/src/model/ModifyAutoSnapshotPolicyRequest.cc new file mode 100644 index 000000000..13411764e --- /dev/null +++ b/dbfs/src/model/ModifyAutoSnapshotPolicyRequest.cc @@ -0,0 +1,85 @@ +/* + * 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::DBFS::Model::ModifyAutoSnapshotPolicyRequest; + +ModifyAutoSnapshotPolicyRequest::ModifyAutoSnapshotPolicyRequest() + : RpcServiceRequest("dbfs", "2020-04-18", "ModifyAutoSnapshotPolicy") { + setMethod(HttpRequest::Method::Post); +} + +ModifyAutoSnapshotPolicyRequest::~ModifyAutoSnapshotPolicyRequest() {} + +std::vector ModifyAutoSnapshotPolicyRequest::getTimePoints() const { + return timePoints_; +} + +void ModifyAutoSnapshotPolicyRequest::setTimePoints(const std::vector &timePoints) { + timePoints_ = timePoints; + for(int dep1 = 0; dep1 != timePoints.size(); dep1++) { + setParameter(std::string("TimePoints") + "." + std::to_string(dep1 + 1), timePoints[dep1]); + } +} + +std::vector ModifyAutoSnapshotPolicyRequest::getRepeatWeekdays() const { + return repeatWeekdays_; +} + +void ModifyAutoSnapshotPolicyRequest::setRepeatWeekdays(const std::vector &repeatWeekdays) { + repeatWeekdays_ = repeatWeekdays; + for(int dep1 = 0; dep1 != repeatWeekdays.size(); dep1++) { + setParameter(std::string("RepeatWeekdays") + "." + std::to_string(dep1 + 1), repeatWeekdays[dep1]); + } +} + +std::string ModifyAutoSnapshotPolicyRequest::getPolicyId() const { + return policyId_; +} + +void ModifyAutoSnapshotPolicyRequest::setPolicyId(const std::string &policyId) { + policyId_ = policyId; + setParameter(std::string("PolicyId"), policyId); +} + +std::string ModifyAutoSnapshotPolicyRequest::getRegionId() const { + return regionId_; +} + +void ModifyAutoSnapshotPolicyRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string ModifyAutoSnapshotPolicyRequest::getPolicyName() const { + return policyName_; +} + +void ModifyAutoSnapshotPolicyRequest::setPolicyName(const std::string &policyName) { + policyName_ = policyName; + setParameter(std::string("PolicyName"), policyName); +} + +int ModifyAutoSnapshotPolicyRequest::getRetentionDays() const { + return retentionDays_; +} + +void ModifyAutoSnapshotPolicyRequest::setRetentionDays(int retentionDays) { + retentionDays_ = retentionDays; + setParameter(std::string("RetentionDays"), std::to_string(retentionDays)); +} + diff --git a/dbfs/src/model/ModifyAutoSnapshotPolicyResult.cc b/dbfs/src/model/ModifyAutoSnapshotPolicyResult.cc new file mode 100644 index 000000000..6bdd7907e --- /dev/null +++ b/dbfs/src/model/ModifyAutoSnapshotPolicyResult.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::DBFS; +using namespace AlibabaCloud::DBFS::Model; + +ModifyAutoSnapshotPolicyResult::ModifyAutoSnapshotPolicyResult() : + ServiceResult() +{} + +ModifyAutoSnapshotPolicyResult::ModifyAutoSnapshotPolicyResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyAutoSnapshotPolicyResult::~ModifyAutoSnapshotPolicyResult() +{} + +void ModifyAutoSnapshotPolicyResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/dbfs/src/model/ModifySnapshotAttributeRequest.cc b/dbfs/src/model/ModifySnapshotAttributeRequest.cc new file mode 100644 index 000000000..ad8fecb60 --- /dev/null +++ b/dbfs/src/model/ModifySnapshotAttributeRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::DBFS::Model::ModifySnapshotAttributeRequest; + +ModifySnapshotAttributeRequest::ModifySnapshotAttributeRequest() + : RpcServiceRequest("dbfs", "2020-04-18", "ModifySnapshotAttribute") { + setMethod(HttpRequest::Method::Post); +} + +ModifySnapshotAttributeRequest::~ModifySnapshotAttributeRequest() {} + +std::string ModifySnapshotAttributeRequest::getSnapshotId() const { + return snapshotId_; +} + +void ModifySnapshotAttributeRequest::setSnapshotId(const std::string &snapshotId) { + snapshotId_ = snapshotId; + setParameter(std::string("SnapshotId"), snapshotId); +} + +std::string ModifySnapshotAttributeRequest::getDescription() const { + return description_; +} + +void ModifySnapshotAttributeRequest::setDescription(const std::string &description) { + description_ = description; + setParameter(std::string("Description"), description); +} + +std::string ModifySnapshotAttributeRequest::getSnapshotName() const { + return snapshotName_; +} + +void ModifySnapshotAttributeRequest::setSnapshotName(const std::string &snapshotName) { + snapshotName_ = snapshotName; + setParameter(std::string("SnapshotName"), snapshotName); +} + +std::string ModifySnapshotAttributeRequest::getRegionId() const { + return regionId_; +} + +void ModifySnapshotAttributeRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + diff --git a/dbfs/src/model/ModifySnapshotAttributeResult.cc b/dbfs/src/model/ModifySnapshotAttributeResult.cc new file mode 100644 index 000000000..955f11950 --- /dev/null +++ b/dbfs/src/model/ModifySnapshotAttributeResult.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::DBFS; +using namespace AlibabaCloud::DBFS::Model; + +ModifySnapshotAttributeResult::ModifySnapshotAttributeResult() : + ServiceResult() +{} + +ModifySnapshotAttributeResult::ModifySnapshotAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifySnapshotAttributeResult::~ModifySnapshotAttributeResult() +{} + +void ModifySnapshotAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} +