diff --git a/VERSION b/VERSION index 4b1226ea7..87c6ca060 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1443 \ No newline at end of file +1.36.1444 \ No newline at end of file diff --git a/schedulerx2/CMakeLists.txt b/schedulerx2/CMakeLists.txt index a2798ea90..8ad22f48e 100644 --- a/schedulerx2/CMakeLists.txt +++ b/schedulerx2/CMakeLists.txt @@ -33,6 +33,8 @@ set(schedulerx2_public_header_model include/alibabacloud/schedulerx2/model/CreateJobResult.h include/alibabacloud/schedulerx2/model/CreateNamespaceRequest.h include/alibabacloud/schedulerx2/model/CreateNamespaceResult.h + include/alibabacloud/schedulerx2/model/CreateWorkflowRequest.h + include/alibabacloud/schedulerx2/model/CreateWorkflowResult.h include/alibabacloud/schedulerx2/model/DeleteJobRequest.h include/alibabacloud/schedulerx2/model/DeleteJobResult.h include/alibabacloud/schedulerx2/model/DeleteWorkflowRequest.h @@ -59,10 +61,14 @@ set(schedulerx2_public_header_model include/alibabacloud/schedulerx2/model/GetJobInstanceResult.h include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h include/alibabacloud/schedulerx2/model/GetJobInstanceListResult.h + include/alibabacloud/schedulerx2/model/GetLogRequest.h + include/alibabacloud/schedulerx2/model/GetLogResult.h include/alibabacloud/schedulerx2/model/GetWorkFlowRequest.h include/alibabacloud/schedulerx2/model/GetWorkFlowResult.h include/alibabacloud/schedulerx2/model/GetWorkerListRequest.h include/alibabacloud/schedulerx2/model/GetWorkerListResult.h + include/alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.h + include/alibabacloud/schedulerx2/model/GetWorkflowInstanceResult.h include/alibabacloud/schedulerx2/model/GrantPermissionRequest.h include/alibabacloud/schedulerx2/model/GrantPermissionResult.h include/alibabacloud/schedulerx2/model/ListGroupsRequest.h @@ -71,12 +77,26 @@ set(schedulerx2_public_header_model include/alibabacloud/schedulerx2/model/ListJobsResult.h include/alibabacloud/schedulerx2/model/ListNamespacesRequest.h include/alibabacloud/schedulerx2/model/ListNamespacesResult.h + include/alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.h + include/alibabacloud/schedulerx2/model/ListWorkflowInstanceResult.h + include/alibabacloud/schedulerx2/model/RerunJobRequest.h + include/alibabacloud/schedulerx2/model/RerunJobResult.h + include/alibabacloud/schedulerx2/model/RetryJobInstanceRequest.h + include/alibabacloud/schedulerx2/model/RetryJobInstanceResult.h include/alibabacloud/schedulerx2/model/RevokePermissionRequest.h include/alibabacloud/schedulerx2/model/RevokePermissionResult.h + include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.h + include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessResult.h + include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.h + include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessResult.h include/alibabacloud/schedulerx2/model/StopInstanceRequest.h include/alibabacloud/schedulerx2/model/StopInstanceResult.h include/alibabacloud/schedulerx2/model/UpdateJobRequest.h - include/alibabacloud/schedulerx2/model/UpdateJobResult.h ) + include/alibabacloud/schedulerx2/model/UpdateJobResult.h + include/alibabacloud/schedulerx2/model/UpdateWorkflowRequest.h + include/alibabacloud/schedulerx2/model/UpdateWorkflowResult.h + include/alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.h + include/alibabacloud/schedulerx2/model/UpdateWorkflowDagResult.h ) set(schedulerx2_src src/Schedulerx2Client.cc @@ -92,6 +112,8 @@ set(schedulerx2_src src/model/CreateJobResult.cc src/model/CreateNamespaceRequest.cc src/model/CreateNamespaceResult.cc + src/model/CreateWorkflowRequest.cc + src/model/CreateWorkflowResult.cc src/model/DeleteJobRequest.cc src/model/DeleteJobResult.cc src/model/DeleteWorkflowRequest.cc @@ -118,10 +140,14 @@ set(schedulerx2_src src/model/GetJobInstanceResult.cc src/model/GetJobInstanceListRequest.cc src/model/GetJobInstanceListResult.cc + src/model/GetLogRequest.cc + src/model/GetLogResult.cc src/model/GetWorkFlowRequest.cc src/model/GetWorkFlowResult.cc src/model/GetWorkerListRequest.cc src/model/GetWorkerListResult.cc + src/model/GetWorkflowInstanceRequest.cc + src/model/GetWorkflowInstanceResult.cc src/model/GrantPermissionRequest.cc src/model/GrantPermissionResult.cc src/model/ListGroupsRequest.cc @@ -130,12 +156,26 @@ set(schedulerx2_src src/model/ListJobsResult.cc src/model/ListNamespacesRequest.cc src/model/ListNamespacesResult.cc + src/model/ListWorkflowInstanceRequest.cc + src/model/ListWorkflowInstanceResult.cc + src/model/RerunJobRequest.cc + src/model/RerunJobResult.cc + src/model/RetryJobInstanceRequest.cc + src/model/RetryJobInstanceResult.cc src/model/RevokePermissionRequest.cc src/model/RevokePermissionResult.cc + src/model/SetJobInstanceSuccessRequest.cc + src/model/SetJobInstanceSuccessResult.cc + src/model/SetWfInstanceSuccessRequest.cc + src/model/SetWfInstanceSuccessResult.cc src/model/StopInstanceRequest.cc src/model/StopInstanceResult.cc src/model/UpdateJobRequest.cc - src/model/UpdateJobResult.cc ) + src/model/UpdateJobResult.cc + src/model/UpdateWorkflowRequest.cc + src/model/UpdateWorkflowResult.cc + src/model/UpdateWorkflowDagRequest.cc + src/model/UpdateWorkflowDagResult.cc ) add_library(schedulerx2 ${LIB_TYPE} ${schedulerx2_public_header} diff --git a/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h b/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h index 3d1e62e30..3e57c0a3b 100644 --- a/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h +++ b/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h @@ -34,6 +34,8 @@ #include "model/CreateJobResult.h" #include "model/CreateNamespaceRequest.h" #include "model/CreateNamespaceResult.h" +#include "model/CreateWorkflowRequest.h" +#include "model/CreateWorkflowResult.h" #include "model/DeleteJobRequest.h" #include "model/DeleteJobResult.h" #include "model/DeleteWorkflowRequest.h" @@ -60,10 +62,14 @@ #include "model/GetJobInstanceResult.h" #include "model/GetJobInstanceListRequest.h" #include "model/GetJobInstanceListResult.h" +#include "model/GetLogRequest.h" +#include "model/GetLogResult.h" #include "model/GetWorkFlowRequest.h" #include "model/GetWorkFlowResult.h" #include "model/GetWorkerListRequest.h" #include "model/GetWorkerListResult.h" +#include "model/GetWorkflowInstanceRequest.h" +#include "model/GetWorkflowInstanceResult.h" #include "model/GrantPermissionRequest.h" #include "model/GrantPermissionResult.h" #include "model/ListGroupsRequest.h" @@ -72,12 +78,26 @@ #include "model/ListJobsResult.h" #include "model/ListNamespacesRequest.h" #include "model/ListNamespacesResult.h" +#include "model/ListWorkflowInstanceRequest.h" +#include "model/ListWorkflowInstanceResult.h" +#include "model/RerunJobRequest.h" +#include "model/RerunJobResult.h" +#include "model/RetryJobInstanceRequest.h" +#include "model/RetryJobInstanceResult.h" #include "model/RevokePermissionRequest.h" #include "model/RevokePermissionResult.h" +#include "model/SetJobInstanceSuccessRequest.h" +#include "model/SetJobInstanceSuccessResult.h" +#include "model/SetWfInstanceSuccessRequest.h" +#include "model/SetWfInstanceSuccessResult.h" #include "model/StopInstanceRequest.h" #include "model/StopInstanceResult.h" #include "model/UpdateJobRequest.h" #include "model/UpdateJobResult.h" +#include "model/UpdateWorkflowRequest.h" +#include "model/UpdateWorkflowResult.h" +#include "model/UpdateWorkflowDagRequest.h" +#include "model/UpdateWorkflowDagResult.h" namespace AlibabaCloud @@ -105,6 +125,9 @@ namespace AlibabaCloud typedef Outcome CreateNamespaceOutcome; typedef std::future CreateNamespaceOutcomeCallable; typedef std::function&)> CreateNamespaceAsyncHandler; + typedef Outcome CreateWorkflowOutcome; + typedef std::future CreateWorkflowOutcomeCallable; + typedef std::function&)> CreateWorkflowAsyncHandler; typedef Outcome DeleteJobOutcome; typedef std::future DeleteJobOutcomeCallable; typedef std::function&)> DeleteJobAsyncHandler; @@ -144,12 +167,18 @@ namespace AlibabaCloud typedef Outcome GetJobInstanceListOutcome; typedef std::future GetJobInstanceListOutcomeCallable; typedef std::function&)> GetJobInstanceListAsyncHandler; + typedef Outcome GetLogOutcome; + typedef std::future GetLogOutcomeCallable; + typedef std::function&)> GetLogAsyncHandler; typedef Outcome GetWorkFlowOutcome; typedef std::future GetWorkFlowOutcomeCallable; typedef std::function&)> GetWorkFlowAsyncHandler; typedef Outcome GetWorkerListOutcome; typedef std::future GetWorkerListOutcomeCallable; typedef std::function&)> GetWorkerListAsyncHandler; + typedef Outcome GetWorkflowInstanceOutcome; + typedef std::future GetWorkflowInstanceOutcomeCallable; + typedef std::function&)> GetWorkflowInstanceAsyncHandler; typedef Outcome GrantPermissionOutcome; typedef std::future GrantPermissionOutcomeCallable; typedef std::function&)> GrantPermissionAsyncHandler; @@ -162,15 +191,36 @@ namespace AlibabaCloud typedef Outcome ListNamespacesOutcome; typedef std::future ListNamespacesOutcomeCallable; typedef std::function&)> ListNamespacesAsyncHandler; + typedef Outcome ListWorkflowInstanceOutcome; + typedef std::future ListWorkflowInstanceOutcomeCallable; + typedef std::function&)> ListWorkflowInstanceAsyncHandler; + typedef Outcome RerunJobOutcome; + typedef std::future RerunJobOutcomeCallable; + typedef std::function&)> RerunJobAsyncHandler; + typedef Outcome RetryJobInstanceOutcome; + typedef std::future RetryJobInstanceOutcomeCallable; + typedef std::function&)> RetryJobInstanceAsyncHandler; typedef Outcome RevokePermissionOutcome; typedef std::future RevokePermissionOutcomeCallable; typedef std::function&)> RevokePermissionAsyncHandler; + typedef Outcome SetJobInstanceSuccessOutcome; + typedef std::future SetJobInstanceSuccessOutcomeCallable; + typedef std::function&)> SetJobInstanceSuccessAsyncHandler; + typedef Outcome SetWfInstanceSuccessOutcome; + typedef std::future SetWfInstanceSuccessOutcomeCallable; + typedef std::function&)> SetWfInstanceSuccessAsyncHandler; typedef Outcome StopInstanceOutcome; typedef std::future StopInstanceOutcomeCallable; typedef std::function&)> StopInstanceAsyncHandler; typedef Outcome UpdateJobOutcome; typedef std::future UpdateJobOutcomeCallable; typedef std::function&)> UpdateJobAsyncHandler; + typedef Outcome UpdateWorkflowOutcome; + typedef std::future UpdateWorkflowOutcomeCallable; + typedef std::function&)> UpdateWorkflowAsyncHandler; + typedef Outcome UpdateWorkflowDagOutcome; + typedef std::future UpdateWorkflowDagOutcomeCallable; + typedef std::function&)> UpdateWorkflowDagAsyncHandler; Schedulerx2Client(const Credentials &credentials, const ClientConfiguration &configuration); Schedulerx2Client(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); @@ -194,6 +244,9 @@ namespace AlibabaCloud CreateNamespaceOutcome createNamespace(const Model::CreateNamespaceRequest &request)const; void createNamespaceAsync(const Model::CreateNamespaceRequest& request, const CreateNamespaceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateNamespaceOutcomeCallable createNamespaceCallable(const Model::CreateNamespaceRequest& request) const; + CreateWorkflowOutcome createWorkflow(const Model::CreateWorkflowRequest &request)const; + void createWorkflowAsync(const Model::CreateWorkflowRequest& request, const CreateWorkflowAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateWorkflowOutcomeCallable createWorkflowCallable(const Model::CreateWorkflowRequest& request) const; DeleteJobOutcome deleteJob(const Model::DeleteJobRequest &request)const; void deleteJobAsync(const Model::DeleteJobRequest& request, const DeleteJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DeleteJobOutcomeCallable deleteJobCallable(const Model::DeleteJobRequest& request) const; @@ -233,12 +286,18 @@ namespace AlibabaCloud GetJobInstanceListOutcome getJobInstanceList(const Model::GetJobInstanceListRequest &request)const; void getJobInstanceListAsync(const Model::GetJobInstanceListRequest& request, const GetJobInstanceListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetJobInstanceListOutcomeCallable getJobInstanceListCallable(const Model::GetJobInstanceListRequest& request) const; + GetLogOutcome getLog(const Model::GetLogRequest &request)const; + void getLogAsync(const Model::GetLogRequest& request, const GetLogAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetLogOutcomeCallable getLogCallable(const Model::GetLogRequest& request) const; GetWorkFlowOutcome getWorkFlow(const Model::GetWorkFlowRequest &request)const; void getWorkFlowAsync(const Model::GetWorkFlowRequest& request, const GetWorkFlowAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetWorkFlowOutcomeCallable getWorkFlowCallable(const Model::GetWorkFlowRequest& request) const; GetWorkerListOutcome getWorkerList(const Model::GetWorkerListRequest &request)const; void getWorkerListAsync(const Model::GetWorkerListRequest& request, const GetWorkerListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetWorkerListOutcomeCallable getWorkerListCallable(const Model::GetWorkerListRequest& request) const; + GetWorkflowInstanceOutcome getWorkflowInstance(const Model::GetWorkflowInstanceRequest &request)const; + void getWorkflowInstanceAsync(const Model::GetWorkflowInstanceRequest& request, const GetWorkflowInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetWorkflowInstanceOutcomeCallable getWorkflowInstanceCallable(const Model::GetWorkflowInstanceRequest& request) const; GrantPermissionOutcome grantPermission(const Model::GrantPermissionRequest &request)const; void grantPermissionAsync(const Model::GrantPermissionRequest& request, const GrantPermissionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GrantPermissionOutcomeCallable grantPermissionCallable(const Model::GrantPermissionRequest& request) const; @@ -251,15 +310,36 @@ namespace AlibabaCloud ListNamespacesOutcome listNamespaces(const Model::ListNamespacesRequest &request)const; void listNamespacesAsync(const Model::ListNamespacesRequest& request, const ListNamespacesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListNamespacesOutcomeCallable listNamespacesCallable(const Model::ListNamespacesRequest& request) const; + ListWorkflowInstanceOutcome listWorkflowInstance(const Model::ListWorkflowInstanceRequest &request)const; + void listWorkflowInstanceAsync(const Model::ListWorkflowInstanceRequest& request, const ListWorkflowInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListWorkflowInstanceOutcomeCallable listWorkflowInstanceCallable(const Model::ListWorkflowInstanceRequest& request) const; + RerunJobOutcome rerunJob(const Model::RerunJobRequest &request)const; + void rerunJobAsync(const Model::RerunJobRequest& request, const RerunJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RerunJobOutcomeCallable rerunJobCallable(const Model::RerunJobRequest& request) const; + RetryJobInstanceOutcome retryJobInstance(const Model::RetryJobInstanceRequest &request)const; + void retryJobInstanceAsync(const Model::RetryJobInstanceRequest& request, const RetryJobInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RetryJobInstanceOutcomeCallable retryJobInstanceCallable(const Model::RetryJobInstanceRequest& request) const; RevokePermissionOutcome revokePermission(const Model::RevokePermissionRequest &request)const; void revokePermissionAsync(const Model::RevokePermissionRequest& request, const RevokePermissionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; RevokePermissionOutcomeCallable revokePermissionCallable(const Model::RevokePermissionRequest& request) const; + SetJobInstanceSuccessOutcome setJobInstanceSuccess(const Model::SetJobInstanceSuccessRequest &request)const; + void setJobInstanceSuccessAsync(const Model::SetJobInstanceSuccessRequest& request, const SetJobInstanceSuccessAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetJobInstanceSuccessOutcomeCallable setJobInstanceSuccessCallable(const Model::SetJobInstanceSuccessRequest& request) const; + SetWfInstanceSuccessOutcome setWfInstanceSuccess(const Model::SetWfInstanceSuccessRequest &request)const; + void setWfInstanceSuccessAsync(const Model::SetWfInstanceSuccessRequest& request, const SetWfInstanceSuccessAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetWfInstanceSuccessOutcomeCallable setWfInstanceSuccessCallable(const Model::SetWfInstanceSuccessRequest& request) const; StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const; void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const; UpdateJobOutcome updateJob(const Model::UpdateJobRequest &request)const; void updateJobAsync(const Model::UpdateJobRequest& request, const UpdateJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateJobOutcomeCallable updateJobCallable(const Model::UpdateJobRequest& request) const; + UpdateWorkflowOutcome updateWorkflow(const Model::UpdateWorkflowRequest &request)const; + void updateWorkflowAsync(const Model::UpdateWorkflowRequest& request, const UpdateWorkflowAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateWorkflowOutcomeCallable updateWorkflowCallable(const Model::UpdateWorkflowRequest& request) const; + UpdateWorkflowDagOutcome updateWorkflowDag(const Model::UpdateWorkflowDagRequest &request)const; + void updateWorkflowDagAsync(const Model::UpdateWorkflowDagRequest& request, const UpdateWorkflowDagAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateWorkflowDagOutcomeCallable updateWorkflowDagCallable(const Model::UpdateWorkflowDagRequest& request) const; private: std::shared_ptr endpointProvider_; diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h index 2fe001281..9900a8a45 100644 --- a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h @@ -52,8 +52,6 @@ public: void setMetricsThresholdJson(const std::string &metricsThresholdJson); std::string getGroupId() const; void setGroupId(const std::string &groupId); - int getAppType() const; - void setAppType(int appType); std::string getMonitorConfigJson() const; void setMonitorConfigJson(const std::string &monitorConfigJson); std::string get_Namespace() const; @@ -73,7 +71,6 @@ private: int maxJobs_; std::string metricsThresholdJson_; std::string groupId_; - int appType_; std::string monitorConfigJson_; std::string _namespace_; std::string appKey_; diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h index 9d4c1b409..575a9a695 100644 --- a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h @@ -38,14 +38,16 @@ public: ~CreateJobRequest(); int getAttemptInterval() const; void setAttemptInterval(int attemptInterval); + int getFailTimes() const; + void setFailTimes(int failTimes); int getConsumerSize() const; void setConsumerSize(int consumerSize); std::string getJarUrl() const; void setJarUrl(const std::string &jarUrl); - int getDataOffset() const; - void setDataOffset(int dataOffset); std::string getGroupId() const; void setGroupId(const std::string &groupId); + int getDataOffset() const; + void setDataOffset(int dataOffset); int getTaskMaxAttempt() const; void setTaskMaxAttempt(int taskMaxAttempt); int getDispatcherSize() const; @@ -94,6 +96,8 @@ public: void setMaxAttempt(int maxAttempt); bool getMissWorkerEnable() const; void setMissWorkerEnable(bool missWorkerEnable); + bool getSuccessNoticeEnable() const; + void setSuccessNoticeEnable(bool successNoticeEnable); int getQueueSize() const; void setQueueSize(int queueSize); std::string getClassName() const; @@ -107,10 +111,11 @@ public: private: int attemptInterval_; + int failTimes_; int consumerSize_; std::string jarUrl_; - int dataOffset_; std::string groupId_; + int dataOffset_; int taskMaxAttempt_; int dispatcherSize_; std::string jobType_; @@ -135,6 +140,7 @@ private: std::string sendChannel_; int maxAttempt_; bool missWorkerEnable_; + bool successNoticeEnable_; int queueSize_; std::string className_; std::string _namespace_; diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowRequest.h new file mode 100644 index 000000000..c3c79ef2b --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowRequest.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEWORKFLOWREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEWORKFLOWREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateWorkflowRequest : public RpcServiceRequest { +public: + CreateWorkflowRequest(); + ~CreateWorkflowRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getTimezone() const; + void setTimezone(const std::string &timezone); + std::string getDescription() const; + void setDescription(const std::string &description); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + std::string getTimeExpression() const; + void setTimeExpression(const std::string &timeExpression); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + std::string getName() const; + void setName(const std::string &name); + int getMaxConcurrency() const; + void setMaxConcurrency(int maxConcurrency); + int getTimeType() const; + void setTimeType(int timeType); + +private: + std::string namespaceSource_; + std::string timezone_; + std::string description_; + std::string regionId_; + std::string groupId_; + std::string timeExpression_; + std::string _namespace_; + std::string name_; + int maxConcurrency_; + int timeType_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEWORKFLOWREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowResult.h new file mode 100644 index 000000000..eafe99a82 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowResult.h @@ -0,0 +1,61 @@ +/* + * 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_SCHEDULERX2_MODEL_CREATEWORKFLOWRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEWORKFLOWRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateWorkflowResult : public ServiceResult + { + public: + struct Data + { + long workflowId; + }; + + + CreateWorkflowResult(); + explicit CreateWorkflowResult(const std::string &payload); + ~CreateWorkflowResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEWORKFLOWRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h index 91a720c63..25ed2d16f 100644 --- a/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h @@ -34,6 +34,8 @@ public: void setNamespaceSource(const std::string &namespaceSource); std::string getGroupId() const; void setGroupId(const std::string &groupId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); std::string get_Namespace() const; void set_Namespace(const std::string &_namespace); long getWorkflowId() const; @@ -44,6 +46,7 @@ public: private: std::string namespaceSource_; std::string groupId_; + std::string regionId_; std::string _namespace_; long workflowId_; std::string instanceParameters_; diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h index 5621e4784..7d242be1e 100644 --- a/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h @@ -34,19 +34,28 @@ public: void setNamespaceSource(const std::string &namespaceSource); std::string getGroupId() const; void setGroupId(const std::string &groupId); + long getStartTimestamp() const; + void setStartTimestamp(long startTimestamp); + long getEndTimestamp() const; + void setEndTimestamp(long endTimestamp); long getJobId() const; void setJobId(long jobId); std::string getRegionId() const; void setRegionId(const std::string ®ionId); std::string get_Namespace() const; void set_Namespace(const std::string &_namespace); + int getStatus() const; + void setStatus(int status); private: std::string namespaceSource_; std::string groupId_; + long startTimestamp_; + long endTimestamp_; long jobId_; std::string regionId_; std::string _namespace_; + int status_; }; } // namespace Model } // namespace Schedulerx2 diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetLogRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetLogRequest.h new file mode 100644 index 000000000..a90b1da23 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetLogRequest.h @@ -0,0 +1,75 @@ +/* + * 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_SCHEDULERX2_MODEL_GETLOGREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETLOGREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT GetLogRequest : public RpcServiceRequest { +public: + GetLogRequest(); + ~GetLogRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + int getLine() const; + void setLine(int line); + long getStartTimestamp() const; + void setStartTimestamp(long startTimestamp); + long getEndTimestamp() const; + void setEndTimestamp(long endTimestamp); + std::string getJobId() const; + void setJobId(const std::string &jobId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getKeyword() const; + void setKeyword(const std::string &keyword); + int getOffset() const; + void setOffset(int offset); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + bool getReverse() const; + void setReverse(bool reverse); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + std::string getJobInstanceId() const; + void setJobInstanceId(const std::string &jobInstanceId); + +private: + std::string namespaceSource_; + int line_; + long startTimestamp_; + long endTimestamp_; + std::string jobId_; + std::string regionId_; + std::string keyword_; + int offset_; + std::string groupId_; + bool reverse_; + std::string _namespace_; + std::string jobInstanceId_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETLOGREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetLogResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetLogResult.h new file mode 100644 index 000000000..c21cf748d --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetLogResult.h @@ -0,0 +1,61 @@ +/* + * 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_SCHEDULERX2_MODEL_GETLOGRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETLOGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GetLogResult : public ServiceResult + { + public: + struct Data + { + std::vector logs; + }; + + + GetLogResult(); + explicit GetLogResult(const std::string &payload); + ~GetLogResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETLOGRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.h new file mode 100644 index 000000000..c864c6d77 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.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_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCEREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT GetWorkflowInstanceRequest : public RpcServiceRequest { +public: + GetWorkflowInstanceRequest(); + ~GetWorkflowInstanceRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + long getWfInstanceId() const; + void setWfInstanceId(long wfInstanceId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + long getWorkflowId() const; + void setWorkflowId(long workflowId); + +private: + std::string namespaceSource_; + std::string groupId_; + long wfInstanceId_; + std::string regionId_; + std::string _namespace_; + long workflowId_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCEREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceResult.h new file mode 100644 index 000000000..8a3f369be --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceResult.h @@ -0,0 +1,92 @@ +/* + * 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_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCERESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GetWorkflowInstanceResult : public ServiceResult + { + public: + struct Data + { + struct WfInstanceInfo + { + int status; + std::string endTime; + std::string scheduleTime; + std::string startTime; + std::string dataTime; + }; + struct WfInstanceDag + { + struct Node + { + std::string endTime; + std::string scheduleTime; + int attempt; + long jobInstanceId; + std::string workAddr; + std::string startTime; + std::string dataTime; + long jobId; + std::string result; + }; + struct Edge + { + long target; + long source; + }; + std::vector edges; + std::vector nodes; + }; + WfInstanceInfo wfInstanceInfo; + WfInstanceDag wfInstanceDag; + }; + + + GetWorkflowInstanceResult(); + explicit GetWorkflowInstanceResult(const std::string &payload); + ~GetWorkflowInstanceResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCERESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/ListGroupsResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/ListGroupsResult.h index 0bbbb26e9..44f354a50 100644 --- a/schedulerx2/include/alibabacloud/schedulerx2/model/ListGroupsResult.h +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/ListGroupsResult.h @@ -37,6 +37,7 @@ namespace AlibabaCloud struct AppGroup { std::string description; + long appGroupId; std::string appKey; std::string appName; std::string groupId; diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.h new file mode 100644 index 000000000..e649f1787 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.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_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCEREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT ListWorkflowInstanceRequest : public RpcServiceRequest { +public: + ListWorkflowInstanceRequest(); + ~ListWorkflowInstanceRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + std::string getWorkflowId() const; + void setWorkflowId(const std::string &workflowId); + +private: + std::string namespaceSource_; + std::string groupId_; + std::string regionId_; + std::string _namespace_; + std::string workflowId_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCEREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceResult.h new file mode 100644 index 000000000..f1b0b17e5 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceResult.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCERESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT ListWorkflowInstanceResult : public ServiceResult + { + public: + struct Data + { + struct WfInstanceInfosItem + { + int status; + std::string endTime; + std::string scheduleTime; + std::string startTime; + std::string dataTime; + long wfInstanceId; + long workflowId; + }; + std::vector wfInstanceInfos; + }; + + + ListWorkflowInstanceResult(); + explicit ListWorkflowInstanceResult(const std::string &payload); + ~ListWorkflowInstanceResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCERESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobRequest.h new file mode 100644 index 000000000..37e332e6d --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobRequest.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT RerunJobRequest : public RpcServiceRequest { +public: + RerunJobRequest(); + ~RerunJobRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getDataTime() const; + void setDataTime(const std::string &dataTime); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + long getStartDate() const; + void setStartDate(long startDate); + long getJobId() const; + void setJobId(long jobId); + long getEndDate() const; + void setEndDate(long endDate); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + +private: + std::string namespaceSource_; + std::string dataTime_; + std::string groupId_; + long startDate_; + long jobId_; + long endDate_; + std::string regionId_; + std::string _namespace_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobResult.h new file mode 100644 index 000000000..5ed151536 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT RerunJobResult : public ServiceResult + { + public: + + + RerunJobResult(); + explicit RerunJobResult(const std::string &payload); + ~RerunJobResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceRequest.h new file mode 100644 index 000000000..2e8ec4c1c --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceRequest.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_SCHEDULERX2_MODEL_RETRYJOBINSTANCEREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT RetryJobInstanceRequest : public RpcServiceRequest { +public: + RetryJobInstanceRequest(); + ~RetryJobInstanceRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + long getJobId() const; + void setJobId(long jobId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + long getJobInstanceId() const; + void setJobInstanceId(long jobInstanceId); + +private: + std::string namespaceSource_; + std::string groupId_; + long jobId_; + std::string regionId_; + std::string _namespace_; + long jobInstanceId_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCEREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceResult.h new file mode 100644 index 000000000..b89df1b7b --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCERESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT RetryJobInstanceResult : public ServiceResult + { + public: + + + RetryJobInstanceResult(); + explicit RetryJobInstanceResult(const std::string &payload); + ~RetryJobInstanceResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCERESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.h new file mode 100644 index 000000000..52b504269 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.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_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT SetJobInstanceSuccessRequest : public RpcServiceRequest { +public: + SetJobInstanceSuccessRequest(); + ~SetJobInstanceSuccessRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + long getJobId() const; + void setJobId(long jobId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + long getJobInstanceId() const; + void setJobInstanceId(long jobInstanceId); + +private: + std::string namespaceSource_; + std::string groupId_; + long jobId_; + std::string regionId_; + std::string _namespace_; + long jobInstanceId_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessResult.h new file mode 100644 index 000000000..c5644034a --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT SetJobInstanceSuccessResult : public ServiceResult + { + public: + + + SetJobInstanceSuccessResult(); + explicit SetJobInstanceSuccessResult(const std::string &payload); + ~SetJobInstanceSuccessResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.h new file mode 100644 index 000000000..a150ef66e --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.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_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT SetWfInstanceSuccessRequest : public RpcServiceRequest { +public: + SetWfInstanceSuccessRequest(); + ~SetWfInstanceSuccessRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + long getWfInstanceId() const; + void setWfInstanceId(long wfInstanceId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + long getWorkflowId() const; + void setWorkflowId(long workflowId); + +private: + std::string namespaceSource_; + std::string groupId_; + long wfInstanceId_; + std::string regionId_; + std::string _namespace_; + long workflowId_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessResult.h new file mode 100644 index 000000000..88427c116 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT SetWfInstanceSuccessResult : public ServiceResult + { + public: + + + SetWfInstanceSuccessResult(); + explicit SetWfInstanceSuccessResult(const std::string &payload); + ~SetWfInstanceSuccessResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h index df5173efe..3ff97351f 100644 --- a/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h @@ -36,104 +36,110 @@ public: }; UpdateJobRequest(); ~UpdateJobRequest(); - std::string getNamespaceSource() const; - void setNamespaceSource(const std::string &namespaceSource); - std::string getDescription() const; - void setDescription(const std::string &description); int getAttemptInterval() const; void setAttemptInterval(int attemptInterval); - std::string getContent() const; - void setContent(const std::string &content); - long getTimeout() const; - void setTimeout(long timeout); - bool getTimeoutKillEnable() const; - void setTimeoutKillEnable(bool timeoutKillEnable); + int getFailTimes() const; + void setFailTimes(int failTimes); long getJobId() const; void setJobId(long jobId); - std::string getRegionId() const; - void setRegionId(const std::string ®ionId); - int getPageSize() const; - void setPageSize(int pageSize); int getConsumerSize() const; void setConsumerSize(int consumerSize); std::string getJarUrl() const; void setJarUrl(const std::string &jarUrl); - std::string getCalendar() const; - void setCalendar(const std::string &calendar); - bool getFailEnable() const; - void setFailEnable(bool failEnable); - std::string getSendChannel() const; - void setSendChannel(const std::string &sendChannel); - int getDataOffset() const; - void setDataOffset(int dataOffset); std::string getGroupId() const; void setGroupId(const std::string &groupId); int getTaskMaxAttempt() const; void setTaskMaxAttempt(int taskMaxAttempt); - int getMaxAttempt() const; - void setMaxAttempt(int maxAttempt); - bool getMissWorkerEnable() const; - void setMissWorkerEnable(bool missWorkerEnable); + int getDataOffset() const; + void setDataOffset(int dataOffset); int getDispatcherSize() const; void setDispatcherSize(int dispatcherSize); int getTaskAttemptInterval() const; void setTaskAttemptInterval(int taskAttemptInterval); std::string getExecuteMode() const; void setExecuteMode(const std::string &executeMode); - int getQueueSize() const; - void setQueueSize(int queueSize); std::string getTimeExpression() const; void setTimeExpression(const std::string &timeExpression); - std::string getClassName() const; - void setClassName(const std::string &className); bool getTimeoutEnable() const; void setTimeoutEnable(bool timeoutEnable); std::vector getContactInfo() const; void setContactInfo(const std::vector &contactInfo); std::string getName() const; void setName(const std::string &name); - std::string get_Namespace() const; - void set_Namespace(const std::string &_namespace); - int getMaxConcurrency() const; - void setMaxConcurrency(int maxConcurrency); int getTimeType() const; void setTimeType(int timeType); std::string getParameters() const; void setParameters(const std::string ¶meters); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getDescription() const; + void setDescription(const std::string &description); + std::string getContent() const; + void setContent(const std::string &content); + long getTimeout() const; + void setTimeout(long timeout); + bool getTimeoutKillEnable() const; + void setTimeoutKillEnable(bool timeoutKillEnable); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + int getPageSize() const; + void setPageSize(int pageSize); + std::string getCalendar() const; + void setCalendar(const std::string &calendar); + bool getFailEnable() const; + void setFailEnable(bool failEnable); + std::string getSendChannel() const; + void setSendChannel(const std::string &sendChannel); + int getMaxAttempt() const; + void setMaxAttempt(int maxAttempt); + bool getMissWorkerEnable() const; + void setMissWorkerEnable(bool missWorkerEnable); + bool getSuccessNoticeEnable() const; + void setSuccessNoticeEnable(bool successNoticeEnable); + int getQueueSize() const; + void setQueueSize(int queueSize); + std::string getClassName() const; + void setClassName(const std::string &className); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + int getMaxConcurrency() const; + void setMaxConcurrency(int maxConcurrency); private: - std::string namespaceSource_; - std::string description_; int attemptInterval_; - std::string content_; - long timeout_; - bool timeoutKillEnable_; + int failTimes_; long jobId_; - std::string regionId_; - int pageSize_; int consumerSize_; std::string jarUrl_; - std::string calendar_; - bool failEnable_; - std::string sendChannel_; - int dataOffset_; std::string groupId_; int taskMaxAttempt_; - int maxAttempt_; - bool missWorkerEnable_; + int dataOffset_; int dispatcherSize_; int taskAttemptInterval_; std::string executeMode_; - int queueSize_; std::string timeExpression_; - std::string className_; bool timeoutEnable_; std::vector contactInfo_; std::string name_; - std::string _namespace_; - int maxConcurrency_; int timeType_; std::string parameters_; + std::string namespaceSource_; + std::string description_; + std::string content_; + long timeout_; + bool timeoutKillEnable_; + std::string regionId_; + int pageSize_; + std::string calendar_; + bool failEnable_; + std::string sendChannel_; + int maxAttempt_; + bool missWorkerEnable_; + bool successNoticeEnable_; + int queueSize_; + std::string className_; + std::string _namespace_; + int maxConcurrency_; }; } // namespace Model } // namespace Schedulerx2 diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.h new file mode 100644 index 000000000..304a446f8 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.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_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateWorkflowDagRequest : public RpcServiceRequest { +public: + UpdateWorkflowDagRequest(); + ~UpdateWorkflowDagRequest(); + std::string getDagJson() const; + void setDagJson(const std::string &dagJson); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + std::string getWorkflowId() const; + void setWorkflowId(const std::string &workflowId); + +private: + std::string dagJson_; + std::string namespaceSource_; + std::string groupId_; + std::string regionId_; + std::string _namespace_; + std::string workflowId_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagResult.h new file mode 100644 index 000000000..76ac13496 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateWorkflowDagResult : public ServiceResult + { + public: + + + UpdateWorkflowDagResult(); + explicit UpdateWorkflowDagResult(const std::string &payload); + ~UpdateWorkflowDagResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowRequest.h new file mode 100644 index 000000000..876954510 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowRequest.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_SCHEDULERX2_MODEL_UPDATEWORKFLOWREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Schedulerx2 { +namespace Model { +class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateWorkflowRequest : public RpcServiceRequest { +public: + UpdateWorkflowRequest(); + ~UpdateWorkflowRequest(); + std::string getNamespaceSource() const; + void setNamespaceSource(const std::string &namespaceSource); + std::string getDescription() const; + void setDescription(const std::string &description); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getWorkflowId() const; + void setWorkflowId(const std::string &workflowId); + std::string getGroupId() const; + void setGroupId(const std::string &groupId); + std::string getTimeExpression() const; + void setTimeExpression(const std::string &timeExpression); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + std::string getName() const; + void setName(const std::string &name); + int getTimeType() const; + void setTimeType(int timeType); + +private: + std::string namespaceSource_; + std::string description_; + std::string regionId_; + std::string workflowId_; + std::string groupId_; + std::string timeExpression_; + std::string _namespace_; + std::string name_; + int timeType_; +}; +} // namespace Model +} // namespace Schedulerx2 +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWREQUEST_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowResult.h new file mode 100644 index 000000000..b16c65877 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateWorkflowResult : public ServiceResult + { + public: + + + UpdateWorkflowResult(); + explicit UpdateWorkflowResult(const std::string &payload); + ~UpdateWorkflowResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/src/Schedulerx2Client.cc b/schedulerx2/src/Schedulerx2Client.cc index 60ad6d362..9a72ca997 100644 --- a/schedulerx2/src/Schedulerx2Client.cc +++ b/schedulerx2/src/Schedulerx2Client.cc @@ -267,6 +267,42 @@ Schedulerx2Client::CreateNamespaceOutcomeCallable Schedulerx2Client::createNames return task->get_future(); } +Schedulerx2Client::CreateWorkflowOutcome Schedulerx2Client::createWorkflow(const CreateWorkflowRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateWorkflowOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateWorkflowOutcome(CreateWorkflowResult(outcome.result())); + else + return CreateWorkflowOutcome(outcome.error()); +} + +void Schedulerx2Client::createWorkflowAsync(const CreateWorkflowRequest& request, const CreateWorkflowAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createWorkflow(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::CreateWorkflowOutcomeCallable Schedulerx2Client::createWorkflowCallable(const CreateWorkflowRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createWorkflow(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Schedulerx2Client::DeleteJobOutcome Schedulerx2Client::deleteJob(const DeleteJobRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -735,6 +771,42 @@ Schedulerx2Client::GetJobInstanceListOutcomeCallable Schedulerx2Client::getJobIn return task->get_future(); } +Schedulerx2Client::GetLogOutcome Schedulerx2Client::getLog(const GetLogRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetLogOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetLogOutcome(GetLogResult(outcome.result())); + else + return GetLogOutcome(outcome.error()); +} + +void Schedulerx2Client::getLogAsync(const GetLogRequest& request, const GetLogAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getLog(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::GetLogOutcomeCallable Schedulerx2Client::getLogCallable(const GetLogRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getLog(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Schedulerx2Client::GetWorkFlowOutcome Schedulerx2Client::getWorkFlow(const GetWorkFlowRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -807,6 +879,42 @@ Schedulerx2Client::GetWorkerListOutcomeCallable Schedulerx2Client::getWorkerList return task->get_future(); } +Schedulerx2Client::GetWorkflowInstanceOutcome Schedulerx2Client::getWorkflowInstance(const GetWorkflowInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetWorkflowInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetWorkflowInstanceOutcome(GetWorkflowInstanceResult(outcome.result())); + else + return GetWorkflowInstanceOutcome(outcome.error()); +} + +void Schedulerx2Client::getWorkflowInstanceAsync(const GetWorkflowInstanceRequest& request, const GetWorkflowInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getWorkflowInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::GetWorkflowInstanceOutcomeCallable Schedulerx2Client::getWorkflowInstanceCallable(const GetWorkflowInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getWorkflowInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Schedulerx2Client::GrantPermissionOutcome Schedulerx2Client::grantPermission(const GrantPermissionRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -951,6 +1059,114 @@ Schedulerx2Client::ListNamespacesOutcomeCallable Schedulerx2Client::listNamespac return task->get_future(); } +Schedulerx2Client::ListWorkflowInstanceOutcome Schedulerx2Client::listWorkflowInstance(const ListWorkflowInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListWorkflowInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListWorkflowInstanceOutcome(ListWorkflowInstanceResult(outcome.result())); + else + return ListWorkflowInstanceOutcome(outcome.error()); +} + +void Schedulerx2Client::listWorkflowInstanceAsync(const ListWorkflowInstanceRequest& request, const ListWorkflowInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listWorkflowInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::ListWorkflowInstanceOutcomeCallable Schedulerx2Client::listWorkflowInstanceCallable(const ListWorkflowInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listWorkflowInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::RerunJobOutcome Schedulerx2Client::rerunJob(const RerunJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RerunJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RerunJobOutcome(RerunJobResult(outcome.result())); + else + return RerunJobOutcome(outcome.error()); +} + +void Schedulerx2Client::rerunJobAsync(const RerunJobRequest& request, const RerunJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, rerunJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::RerunJobOutcomeCallable Schedulerx2Client::rerunJobCallable(const RerunJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->rerunJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::RetryJobInstanceOutcome Schedulerx2Client::retryJobInstance(const RetryJobInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RetryJobInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RetryJobInstanceOutcome(RetryJobInstanceResult(outcome.result())); + else + return RetryJobInstanceOutcome(outcome.error()); +} + +void Schedulerx2Client::retryJobInstanceAsync(const RetryJobInstanceRequest& request, const RetryJobInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, retryJobInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::RetryJobInstanceOutcomeCallable Schedulerx2Client::retryJobInstanceCallable(const RetryJobInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->retryJobInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Schedulerx2Client::RevokePermissionOutcome Schedulerx2Client::revokePermission(const RevokePermissionRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -987,6 +1203,78 @@ Schedulerx2Client::RevokePermissionOutcomeCallable Schedulerx2Client::revokePerm return task->get_future(); } +Schedulerx2Client::SetJobInstanceSuccessOutcome Schedulerx2Client::setJobInstanceSuccess(const SetJobInstanceSuccessRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return SetJobInstanceSuccessOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetJobInstanceSuccessOutcome(SetJobInstanceSuccessResult(outcome.result())); + else + return SetJobInstanceSuccessOutcome(outcome.error()); +} + +void Schedulerx2Client::setJobInstanceSuccessAsync(const SetJobInstanceSuccessRequest& request, const SetJobInstanceSuccessAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setJobInstanceSuccess(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::SetJobInstanceSuccessOutcomeCallable Schedulerx2Client::setJobInstanceSuccessCallable(const SetJobInstanceSuccessRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setJobInstanceSuccess(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::SetWfInstanceSuccessOutcome Schedulerx2Client::setWfInstanceSuccess(const SetWfInstanceSuccessRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return SetWfInstanceSuccessOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetWfInstanceSuccessOutcome(SetWfInstanceSuccessResult(outcome.result())); + else + return SetWfInstanceSuccessOutcome(outcome.error()); +} + +void Schedulerx2Client::setWfInstanceSuccessAsync(const SetWfInstanceSuccessRequest& request, const SetWfInstanceSuccessAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setWfInstanceSuccess(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::SetWfInstanceSuccessOutcomeCallable Schedulerx2Client::setWfInstanceSuccessCallable(const SetWfInstanceSuccessRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setWfInstanceSuccess(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Schedulerx2Client::StopInstanceOutcome Schedulerx2Client::stopInstance(const StopInstanceRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1059,3 +1347,75 @@ Schedulerx2Client::UpdateJobOutcomeCallable Schedulerx2Client::updateJobCallable return task->get_future(); } +Schedulerx2Client::UpdateWorkflowOutcome Schedulerx2Client::updateWorkflow(const UpdateWorkflowRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateWorkflowOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateWorkflowOutcome(UpdateWorkflowResult(outcome.result())); + else + return UpdateWorkflowOutcome(outcome.error()); +} + +void Schedulerx2Client::updateWorkflowAsync(const UpdateWorkflowRequest& request, const UpdateWorkflowAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateWorkflow(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::UpdateWorkflowOutcomeCallable Schedulerx2Client::updateWorkflowCallable(const UpdateWorkflowRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateWorkflow(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::UpdateWorkflowDagOutcome Schedulerx2Client::updateWorkflowDag(const UpdateWorkflowDagRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateWorkflowDagOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateWorkflowDagOutcome(UpdateWorkflowDagResult(outcome.result())); + else + return UpdateWorkflowDagOutcome(outcome.error()); +} + +void Schedulerx2Client::updateWorkflowDagAsync(const UpdateWorkflowDagRequest& request, const UpdateWorkflowDagAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateWorkflowDag(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::UpdateWorkflowDagOutcomeCallable Schedulerx2Client::updateWorkflowDagCallable(const UpdateWorkflowDagRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateWorkflowDag(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/schedulerx2/src/model/CreateAppGroupRequest.cc b/schedulerx2/src/model/CreateAppGroupRequest.cc index f13f0fbe5..df54d78a9 100644 --- a/schedulerx2/src/model/CreateAppGroupRequest.cc +++ b/schedulerx2/src/model/CreateAppGroupRequest.cc @@ -124,15 +124,6 @@ void CreateAppGroupRequest::setGroupId(const std::string &groupId) { setParameter(std::string("GroupId"), groupId); } -int CreateAppGroupRequest::getAppType() const { - return appType_; -} - -void CreateAppGroupRequest::setAppType(int appType) { - appType_ = appType; - setParameter(std::string("AppType"), std::to_string(appType)); -} - std::string CreateAppGroupRequest::getMonitorConfigJson() const { return monitorConfigJson_; } diff --git a/schedulerx2/src/model/CreateJobRequest.cc b/schedulerx2/src/model/CreateJobRequest.cc index eb1bd450d..c6ea8ea41 100644 --- a/schedulerx2/src/model/CreateJobRequest.cc +++ b/schedulerx2/src/model/CreateJobRequest.cc @@ -34,6 +34,15 @@ void CreateJobRequest::setAttemptInterval(int attemptInterval) { setBodyParameter(std::string("AttemptInterval"), std::to_string(attemptInterval)); } +int CreateJobRequest::getFailTimes() const { + return failTimes_; +} + +void CreateJobRequest::setFailTimes(int failTimes) { + failTimes_ = failTimes; + setBodyParameter(std::string("FailTimes"), std::to_string(failTimes)); +} + int CreateJobRequest::getConsumerSize() const { return consumerSize_; } @@ -52,15 +61,6 @@ void CreateJobRequest::setJarUrl(const std::string &jarUrl) { setBodyParameter(std::string("JarUrl"), jarUrl); } -int CreateJobRequest::getDataOffset() const { - return dataOffset_; -} - -void CreateJobRequest::setDataOffset(int dataOffset) { - dataOffset_ = dataOffset; - setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset)); -} - std::string CreateJobRequest::getGroupId() const { return groupId_; } @@ -70,6 +70,15 @@ void CreateJobRequest::setGroupId(const std::string &groupId) { setBodyParameter(std::string("GroupId"), groupId); } +int CreateJobRequest::getDataOffset() const { + return dataOffset_; +} + +void CreateJobRequest::setDataOffset(int dataOffset) { + dataOffset_ = dataOffset; + setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset)); +} + int CreateJobRequest::getTaskMaxAttempt() const { return taskMaxAttempt_; } @@ -293,6 +302,15 @@ void CreateJobRequest::setMissWorkerEnable(bool missWorkerEnable) { setBodyParameter(std::string("MissWorkerEnable"), missWorkerEnable ? "true" : "false"); } +bool CreateJobRequest::getSuccessNoticeEnable() const { + return successNoticeEnable_; +} + +void CreateJobRequest::setSuccessNoticeEnable(bool successNoticeEnable) { + successNoticeEnable_ = successNoticeEnable; + setBodyParameter(std::string("SuccessNoticeEnable"), successNoticeEnable ? "true" : "false"); +} + int CreateJobRequest::getQueueSize() const { return queueSize_; } diff --git a/schedulerx2/src/model/CreateWorkflowRequest.cc b/schedulerx2/src/model/CreateWorkflowRequest.cc new file mode 100644 index 000000000..cbd674f0f --- /dev/null +++ b/schedulerx2/src/model/CreateWorkflowRequest.cc @@ -0,0 +1,117 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Schedulerx2::Model::CreateWorkflowRequest; + +CreateWorkflowRequest::CreateWorkflowRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "CreateWorkflow") { + setMethod(HttpRequest::Method::Post); +} + +CreateWorkflowRequest::~CreateWorkflowRequest() {} + +std::string CreateWorkflowRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void CreateWorkflowRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setBodyParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string CreateWorkflowRequest::getTimezone() const { + return timezone_; +} + +void CreateWorkflowRequest::setTimezone(const std::string &timezone) { + timezone_ = timezone; + setBodyParameter(std::string("Timezone"), timezone); +} + +std::string CreateWorkflowRequest::getDescription() const { + return description_; +} + +void CreateWorkflowRequest::setDescription(const std::string &description) { + description_ = description; + setBodyParameter(std::string("Description"), description); +} + +std::string CreateWorkflowRequest::getRegionId() const { + return regionId_; +} + +void CreateWorkflowRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string CreateWorkflowRequest::getGroupId() const { + return groupId_; +} + +void CreateWorkflowRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setBodyParameter(std::string("GroupId"), groupId); +} + +std::string CreateWorkflowRequest::getTimeExpression() const { + return timeExpression_; +} + +void CreateWorkflowRequest::setTimeExpression(const std::string &timeExpression) { + timeExpression_ = timeExpression; + setBodyParameter(std::string("TimeExpression"), timeExpression); +} + +std::string CreateWorkflowRequest::get_Namespace() const { + return _namespace_; +} + +void CreateWorkflowRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setBodyParameter(std::string("Namespace"), _namespace); +} + +std::string CreateWorkflowRequest::getName() const { + return name_; +} + +void CreateWorkflowRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + +int CreateWorkflowRequest::getMaxConcurrency() const { + return maxConcurrency_; +} + +void CreateWorkflowRequest::setMaxConcurrency(int maxConcurrency) { + maxConcurrency_ = maxConcurrency; + setBodyParameter(std::string("MaxConcurrency"), std::to_string(maxConcurrency)); +} + +int CreateWorkflowRequest::getTimeType() const { + return timeType_; +} + +void CreateWorkflowRequest::setTimeType(int timeType) { + timeType_ = timeType; + setBodyParameter(std::string("TimeType"), std::to_string(timeType)); +} + diff --git a/schedulerx2/src/model/CreateWorkflowResult.cc b/schedulerx2/src/model/CreateWorkflowResult.cc new file mode 100644 index 000000000..cbc8b11b5 --- /dev/null +++ b/schedulerx2/src/model/CreateWorkflowResult.cc @@ -0,0 +1,73 @@ +/* + * 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::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +CreateWorkflowResult::CreateWorkflowResult() : + ServiceResult() +{} + +CreateWorkflowResult::CreateWorkflowResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateWorkflowResult::~CreateWorkflowResult() +{} + +void CreateWorkflowResult::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["WorkflowId"].isNull()) + data_.workflowId = std::stol(dataNode["WorkflowId"].asString()); + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string CreateWorkflowResult::getMessage()const +{ + return message_; +} + +CreateWorkflowResult::Data CreateWorkflowResult::getData()const +{ + return data_; +} + +std::string CreateWorkflowResult::getCode()const +{ + return code_; +} + +bool CreateWorkflowResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/ExecuteWorkflowRequest.cc b/schedulerx2/src/model/ExecuteWorkflowRequest.cc index 7bb424771..ed40ae761 100644 --- a/schedulerx2/src/model/ExecuteWorkflowRequest.cc +++ b/schedulerx2/src/model/ExecuteWorkflowRequest.cc @@ -43,6 +43,15 @@ void ExecuteWorkflowRequest::setGroupId(const std::string &groupId) { setParameter(std::string("GroupId"), groupId); } +std::string ExecuteWorkflowRequest::getRegionId() const { + return regionId_; +} + +void ExecuteWorkflowRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + std::string ExecuteWorkflowRequest::get_Namespace() const { return _namespace_; } diff --git a/schedulerx2/src/model/GetJobInstanceListRequest.cc b/schedulerx2/src/model/GetJobInstanceListRequest.cc index 527195e3b..5b86e6b3b 100644 --- a/schedulerx2/src/model/GetJobInstanceListRequest.cc +++ b/schedulerx2/src/model/GetJobInstanceListRequest.cc @@ -43,6 +43,24 @@ void GetJobInstanceListRequest::setGroupId(const std::string &groupId) { setParameter(std::string("GroupId"), groupId); } +long GetJobInstanceListRequest::getStartTimestamp() const { + return startTimestamp_; +} + +void GetJobInstanceListRequest::setStartTimestamp(long startTimestamp) { + startTimestamp_ = startTimestamp; + setParameter(std::string("StartTimestamp"), std::to_string(startTimestamp)); +} + +long GetJobInstanceListRequest::getEndTimestamp() const { + return endTimestamp_; +} + +void GetJobInstanceListRequest::setEndTimestamp(long endTimestamp) { + endTimestamp_ = endTimestamp; + setParameter(std::string("EndTimestamp"), std::to_string(endTimestamp)); +} + long GetJobInstanceListRequest::getJobId() const { return jobId_; } @@ -70,3 +88,12 @@ void GetJobInstanceListRequest::set_Namespace(const std::string &_namespace) { setParameter(std::string("Namespace"), _namespace); } +int GetJobInstanceListRequest::getStatus() const { + return status_; +} + +void GetJobInstanceListRequest::setStatus(int status) { + status_ = status; + setParameter(std::string("Status"), std::to_string(status)); +} + diff --git a/schedulerx2/src/model/GetLogRequest.cc b/schedulerx2/src/model/GetLogRequest.cc new file mode 100644 index 000000000..99a9e215a --- /dev/null +++ b/schedulerx2/src/model/GetLogRequest.cc @@ -0,0 +1,135 @@ +/* + * 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::Schedulerx2::Model::GetLogRequest; + +GetLogRequest::GetLogRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "GetLog") { + setMethod(HttpRequest::Method::Get); +} + +GetLogRequest::~GetLogRequest() {} + +std::string GetLogRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void GetLogRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setParameter(std::string("NamespaceSource"), namespaceSource); +} + +int GetLogRequest::getLine() const { + return line_; +} + +void GetLogRequest::setLine(int line) { + line_ = line; + setParameter(std::string("Line"), std::to_string(line)); +} + +long GetLogRequest::getStartTimestamp() const { + return startTimestamp_; +} + +void GetLogRequest::setStartTimestamp(long startTimestamp) { + startTimestamp_ = startTimestamp; + setParameter(std::string("StartTimestamp"), std::to_string(startTimestamp)); +} + +long GetLogRequest::getEndTimestamp() const { + return endTimestamp_; +} + +void GetLogRequest::setEndTimestamp(long endTimestamp) { + endTimestamp_ = endTimestamp; + setParameter(std::string("EndTimestamp"), std::to_string(endTimestamp)); +} + +std::string GetLogRequest::getJobId() const { + return jobId_; +} + +void GetLogRequest::setJobId(const std::string &jobId) { + jobId_ = jobId; + setParameter(std::string("JobId"), jobId); +} + +std::string GetLogRequest::getRegionId() const { + return regionId_; +} + +void GetLogRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string GetLogRequest::getKeyword() const { + return keyword_; +} + +void GetLogRequest::setKeyword(const std::string &keyword) { + keyword_ = keyword; + setParameter(std::string("Keyword"), keyword); +} + +int GetLogRequest::getOffset() const { + return offset_; +} + +void GetLogRequest::setOffset(int offset) { + offset_ = offset; + setParameter(std::string("Offset"), std::to_string(offset)); +} + +std::string GetLogRequest::getGroupId() const { + return groupId_; +} + +void GetLogRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setParameter(std::string("GroupId"), groupId); +} + +bool GetLogRequest::getReverse() const { + return reverse_; +} + +void GetLogRequest::setReverse(bool reverse) { + reverse_ = reverse; + setParameter(std::string("Reverse"), reverse ? "true" : "false"); +} + +std::string GetLogRequest::get_Namespace() const { + return _namespace_; +} + +void GetLogRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + +std::string GetLogRequest::getJobInstanceId() const { + return jobInstanceId_; +} + +void GetLogRequest::setJobInstanceId(const std::string &jobInstanceId) { + jobInstanceId_ = jobInstanceId; + setParameter(std::string("JobInstanceId"), jobInstanceId); +} + diff --git a/schedulerx2/src/model/GetLogResult.cc b/schedulerx2/src/model/GetLogResult.cc new file mode 100644 index 000000000..c1a370451 --- /dev/null +++ b/schedulerx2/src/model/GetLogResult.cc @@ -0,0 +1,74 @@ +/* + * 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::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +GetLogResult::GetLogResult() : + ServiceResult() +{} + +GetLogResult::GetLogResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetLogResult::~GetLogResult() +{} + +void GetLogResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allLogs = dataNode["Logs"]["Logs"]; + for (auto value : allLogs) + data_.logs.push_back(value.asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string GetLogResult::getMessage()const +{ + return message_; +} + +GetLogResult::Data GetLogResult::getData()const +{ + return data_; +} + +int GetLogResult::getCode()const +{ + return code_; +} + +bool GetLogResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/GetWorkflowInstanceRequest.cc b/schedulerx2/src/model/GetWorkflowInstanceRequest.cc new file mode 100644 index 000000000..3f82d1f12 --- /dev/null +++ b/schedulerx2/src/model/GetWorkflowInstanceRequest.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::Schedulerx2::Model::GetWorkflowInstanceRequest; + +GetWorkflowInstanceRequest::GetWorkflowInstanceRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "GetWorkflowInstance") { + setMethod(HttpRequest::Method::Get); +} + +GetWorkflowInstanceRequest::~GetWorkflowInstanceRequest() {} + +std::string GetWorkflowInstanceRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void GetWorkflowInstanceRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string GetWorkflowInstanceRequest::getGroupId() const { + return groupId_; +} + +void GetWorkflowInstanceRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setParameter(std::string("GroupId"), groupId); +} + +long GetWorkflowInstanceRequest::getWfInstanceId() const { + return wfInstanceId_; +} + +void GetWorkflowInstanceRequest::setWfInstanceId(long wfInstanceId) { + wfInstanceId_ = wfInstanceId; + setParameter(std::string("WfInstanceId"), std::to_string(wfInstanceId)); +} + +std::string GetWorkflowInstanceRequest::getRegionId() const { + return regionId_; +} + +void GetWorkflowInstanceRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string GetWorkflowInstanceRequest::get_Namespace() const { + return _namespace_; +} + +void GetWorkflowInstanceRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + +long GetWorkflowInstanceRequest::getWorkflowId() const { + return workflowId_; +} + +void GetWorkflowInstanceRequest::setWorkflowId(long workflowId) { + workflowId_ = workflowId; + setParameter(std::string("WorkflowId"), std::to_string(workflowId)); +} + diff --git a/schedulerx2/src/model/GetWorkflowInstanceResult.cc b/schedulerx2/src/model/GetWorkflowInstanceResult.cc new file mode 100644 index 000000000..a562e7e94 --- /dev/null +++ b/schedulerx2/src/model/GetWorkflowInstanceResult.cc @@ -0,0 +1,117 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +GetWorkflowInstanceResult::GetWorkflowInstanceResult() : + ServiceResult() +{} + +GetWorkflowInstanceResult::GetWorkflowInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetWorkflowInstanceResult::~GetWorkflowInstanceResult() +{} + +void GetWorkflowInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto wfInstanceInfoNode = dataNode["WfInstanceInfo"]; + if(!wfInstanceInfoNode["Status"].isNull()) + data_.wfInstanceInfo.status = std::stoi(wfInstanceInfoNode["Status"].asString()); + if(!wfInstanceInfoNode["StartTime"].isNull()) + data_.wfInstanceInfo.startTime = wfInstanceInfoNode["StartTime"].asString(); + if(!wfInstanceInfoNode["EndTime"].isNull()) + data_.wfInstanceInfo.endTime = wfInstanceInfoNode["EndTime"].asString(); + if(!wfInstanceInfoNode["ScheduleTime"].isNull()) + data_.wfInstanceInfo.scheduleTime = wfInstanceInfoNode["ScheduleTime"].asString(); + if(!wfInstanceInfoNode["DataTime"].isNull()) + data_.wfInstanceInfo.dataTime = wfInstanceInfoNode["DataTime"].asString(); + auto wfInstanceDagNode = dataNode["WfInstanceDag"]; + auto allNodesNode = wfInstanceDagNode["Nodes"]["Node"]; + for (auto wfInstanceDagNodeNodesNode : allNodesNode) + { + Data::WfInstanceDag::Node nodeObject; + if(!wfInstanceDagNodeNodesNode["JobInstanceId"].isNull()) + nodeObject.jobInstanceId = std::stol(wfInstanceDagNodeNodesNode["JobInstanceId"].asString()); + if(!wfInstanceDagNodeNodesNode["JobId"].isNull()) + nodeObject.jobId = std::stol(wfInstanceDagNodeNodesNode["JobId"].asString()); + if(!wfInstanceDagNodeNodesNode["StartTime"].isNull()) + nodeObject.startTime = wfInstanceDagNodeNodesNode["StartTime"].asString(); + if(!wfInstanceDagNodeNodesNode["EndTime"].isNull()) + nodeObject.endTime = wfInstanceDagNodeNodesNode["EndTime"].asString(); + if(!wfInstanceDagNodeNodesNode["ScheduleTime"].isNull()) + nodeObject.scheduleTime = wfInstanceDagNodeNodesNode["ScheduleTime"].asString(); + if(!wfInstanceDagNodeNodesNode["DataTime"].isNull()) + nodeObject.dataTime = wfInstanceDagNodeNodesNode["DataTime"].asString(); + if(!wfInstanceDagNodeNodesNode["WorkAddr"].isNull()) + nodeObject.workAddr = wfInstanceDagNodeNodesNode["WorkAddr"].asString(); + if(!wfInstanceDagNodeNodesNode["Result"].isNull()) + nodeObject.result = wfInstanceDagNodeNodesNode["Result"].asString(); + if(!wfInstanceDagNodeNodesNode["Attempt"].isNull()) + nodeObject.attempt = std::stoi(wfInstanceDagNodeNodesNode["Attempt"].asString()); + data_.wfInstanceDag.nodes.push_back(nodeObject); + } + auto allEdgesNode = wfInstanceDagNode["Edges"]["Edge"]; + for (auto wfInstanceDagNodeEdgesEdge : allEdgesNode) + { + Data::WfInstanceDag::Edge edgeObject; + if(!wfInstanceDagNodeEdgesEdge["Source"].isNull()) + edgeObject.source = std::stol(wfInstanceDagNodeEdgesEdge["Source"].asString()); + if(!wfInstanceDagNodeEdgesEdge["Target"].isNull()) + edgeObject.target = std::stol(wfInstanceDagNodeEdgesEdge["Target"].asString()); + data_.wfInstanceDag.edges.push_back(edgeObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string GetWorkflowInstanceResult::getMessage()const +{ + return message_; +} + +GetWorkflowInstanceResult::Data GetWorkflowInstanceResult::getData()const +{ + return data_; +} + +int GetWorkflowInstanceResult::getCode()const +{ + return code_; +} + +bool GetWorkflowInstanceResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/ListGroupsResult.cc b/schedulerx2/src/model/ListGroupsResult.cc index 9f0d6d870..7365a3597 100644 --- a/schedulerx2/src/model/ListGroupsResult.cc +++ b/schedulerx2/src/model/ListGroupsResult.cc @@ -44,6 +44,8 @@ void ListGroupsResult::parse(const std::string &payload) for (auto dataNodeAppGroupsAppGroup : allAppGroupsNode) { Data::AppGroup appGroupObject; + if(!dataNodeAppGroupsAppGroup["AppGroupId"].isNull()) + appGroupObject.appGroupId = std::stol(dataNodeAppGroupsAppGroup["AppGroupId"].asString()); if(!dataNodeAppGroupsAppGroup["AppName"].isNull()) appGroupObject.appName = dataNodeAppGroupsAppGroup["AppName"].asString(); if(!dataNodeAppGroupsAppGroup["AppKey"].isNull()) diff --git a/schedulerx2/src/model/ListWorkflowInstanceRequest.cc b/schedulerx2/src/model/ListWorkflowInstanceRequest.cc new file mode 100644 index 000000000..e2d8a34e3 --- /dev/null +++ b/schedulerx2/src/model/ListWorkflowInstanceRequest.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::Schedulerx2::Model::ListWorkflowInstanceRequest; + +ListWorkflowInstanceRequest::ListWorkflowInstanceRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "ListWorkflowInstance") { + setMethod(HttpRequest::Method::Get); +} + +ListWorkflowInstanceRequest::~ListWorkflowInstanceRequest() {} + +std::string ListWorkflowInstanceRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void ListWorkflowInstanceRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string ListWorkflowInstanceRequest::getGroupId() const { + return groupId_; +} + +void ListWorkflowInstanceRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setParameter(std::string("GroupId"), groupId); +} + +std::string ListWorkflowInstanceRequest::getRegionId() const { + return regionId_; +} + +void ListWorkflowInstanceRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string ListWorkflowInstanceRequest::get_Namespace() const { + return _namespace_; +} + +void ListWorkflowInstanceRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + +std::string ListWorkflowInstanceRequest::getWorkflowId() const { + return workflowId_; +} + +void ListWorkflowInstanceRequest::setWorkflowId(const std::string &workflowId) { + workflowId_ = workflowId; + setParameter(std::string("WorkflowId"), workflowId); +} + diff --git a/schedulerx2/src/model/ListWorkflowInstanceResult.cc b/schedulerx2/src/model/ListWorkflowInstanceResult.cc new file mode 100644 index 000000000..5e58b4fc2 --- /dev/null +++ b/schedulerx2/src/model/ListWorkflowInstanceResult.cc @@ -0,0 +1,91 @@ +/* + * 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::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +ListWorkflowInstanceResult::ListWorkflowInstanceResult() : + ServiceResult() +{} + +ListWorkflowInstanceResult::ListWorkflowInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListWorkflowInstanceResult::~ListWorkflowInstanceResult() +{} + +void ListWorkflowInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allWfInstanceInfosNode = dataNode["WfInstanceInfos"]["WfInstanceInfosItem"]; + for (auto dataNodeWfInstanceInfosWfInstanceInfosItem : allWfInstanceInfosNode) + { + Data::WfInstanceInfosItem wfInstanceInfosItemObject; + if(!dataNodeWfInstanceInfosWfInstanceInfosItem["WfInstanceId"].isNull()) + wfInstanceInfosItemObject.wfInstanceId = std::stol(dataNodeWfInstanceInfosWfInstanceInfosItem["WfInstanceId"].asString()); + if(!dataNodeWfInstanceInfosWfInstanceInfosItem["WorkflowId"].isNull()) + wfInstanceInfosItemObject.workflowId = std::stol(dataNodeWfInstanceInfosWfInstanceInfosItem["WorkflowId"].asString()); + if(!dataNodeWfInstanceInfosWfInstanceInfosItem["Status"].isNull()) + wfInstanceInfosItemObject.status = std::stoi(dataNodeWfInstanceInfosWfInstanceInfosItem["Status"].asString()); + if(!dataNodeWfInstanceInfosWfInstanceInfosItem["StartTime"].isNull()) + wfInstanceInfosItemObject.startTime = dataNodeWfInstanceInfosWfInstanceInfosItem["StartTime"].asString(); + if(!dataNodeWfInstanceInfosWfInstanceInfosItem["EndTime"].isNull()) + wfInstanceInfosItemObject.endTime = dataNodeWfInstanceInfosWfInstanceInfosItem["EndTime"].asString(); + if(!dataNodeWfInstanceInfosWfInstanceInfosItem["ScheduleTime"].isNull()) + wfInstanceInfosItemObject.scheduleTime = dataNodeWfInstanceInfosWfInstanceInfosItem["ScheduleTime"].asString(); + if(!dataNodeWfInstanceInfosWfInstanceInfosItem["DataTime"].isNull()) + wfInstanceInfosItemObject.dataTime = dataNodeWfInstanceInfosWfInstanceInfosItem["DataTime"].asString(); + data_.wfInstanceInfos.push_back(wfInstanceInfosItemObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string ListWorkflowInstanceResult::getMessage()const +{ + return message_; +} + +ListWorkflowInstanceResult::Data ListWorkflowInstanceResult::getData()const +{ + return data_; +} + +int ListWorkflowInstanceResult::getCode()const +{ + return code_; +} + +bool ListWorkflowInstanceResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/RerunJobRequest.cc b/schedulerx2/src/model/RerunJobRequest.cc new file mode 100644 index 000000000..1eb0c24f2 --- /dev/null +++ b/schedulerx2/src/model/RerunJobRequest.cc @@ -0,0 +1,99 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Schedulerx2::Model::RerunJobRequest; + +RerunJobRequest::RerunJobRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "RerunJob") { + setMethod(HttpRequest::Method::Post); +} + +RerunJobRequest::~RerunJobRequest() {} + +std::string RerunJobRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void RerunJobRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setBodyParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string RerunJobRequest::getDataTime() const { + return dataTime_; +} + +void RerunJobRequest::setDataTime(const std::string &dataTime) { + dataTime_ = dataTime; + setBodyParameter(std::string("DataTime"), dataTime); +} + +std::string RerunJobRequest::getGroupId() const { + return groupId_; +} + +void RerunJobRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setBodyParameter(std::string("GroupId"), groupId); +} + +long RerunJobRequest::getStartDate() const { + return startDate_; +} + +void RerunJobRequest::setStartDate(long startDate) { + startDate_ = startDate; + setBodyParameter(std::string("StartDate"), std::to_string(startDate)); +} + +long RerunJobRequest::getJobId() const { + return jobId_; +} + +void RerunJobRequest::setJobId(long jobId) { + jobId_ = jobId; + setBodyParameter(std::string("JobId"), std::to_string(jobId)); +} + +long RerunJobRequest::getEndDate() const { + return endDate_; +} + +void RerunJobRequest::setEndDate(long endDate) { + endDate_ = endDate; + setBodyParameter(std::string("EndDate"), std::to_string(endDate)); +} + +std::string RerunJobRequest::getRegionId() const { + return regionId_; +} + +void RerunJobRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string RerunJobRequest::get_Namespace() const { + return _namespace_; +} + +void RerunJobRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setBodyParameter(std::string("Namespace"), _namespace); +} + diff --git a/schedulerx2/src/model/RerunJobResult.cc b/schedulerx2/src/model/RerunJobResult.cc new file mode 100644 index 000000000..8438a7d1c --- /dev/null +++ b/schedulerx2/src/model/RerunJobResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +RerunJobResult::RerunJobResult() : + ServiceResult() +{} + +RerunJobResult::RerunJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RerunJobResult::~RerunJobResult() +{} + +void RerunJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string RerunJobResult::getMessage()const +{ + return message_; +} + +int RerunJobResult::getCode()const +{ + return code_; +} + +bool RerunJobResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/RetryJobInstanceRequest.cc b/schedulerx2/src/model/RetryJobInstanceRequest.cc new file mode 100644 index 000000000..46c63a467 --- /dev/null +++ b/schedulerx2/src/model/RetryJobInstanceRequest.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::Schedulerx2::Model::RetryJobInstanceRequest; + +RetryJobInstanceRequest::RetryJobInstanceRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "RetryJobInstance") { + setMethod(HttpRequest::Method::Post); +} + +RetryJobInstanceRequest::~RetryJobInstanceRequest() {} + +std::string RetryJobInstanceRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void RetryJobInstanceRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string RetryJobInstanceRequest::getGroupId() const { + return groupId_; +} + +void RetryJobInstanceRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setParameter(std::string("GroupId"), groupId); +} + +long RetryJobInstanceRequest::getJobId() const { + return jobId_; +} + +void RetryJobInstanceRequest::setJobId(long jobId) { + jobId_ = jobId; + setParameter(std::string("JobId"), std::to_string(jobId)); +} + +std::string RetryJobInstanceRequest::getRegionId() const { + return regionId_; +} + +void RetryJobInstanceRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string RetryJobInstanceRequest::get_Namespace() const { + return _namespace_; +} + +void RetryJobInstanceRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + +long RetryJobInstanceRequest::getJobInstanceId() const { + return jobInstanceId_; +} + +void RetryJobInstanceRequest::setJobInstanceId(long jobInstanceId) { + jobInstanceId_ = jobInstanceId; + setParameter(std::string("JobInstanceId"), std::to_string(jobInstanceId)); +} + diff --git a/schedulerx2/src/model/RetryJobInstanceResult.cc b/schedulerx2/src/model/RetryJobInstanceResult.cc new file mode 100644 index 000000000..a5348225f --- /dev/null +++ b/schedulerx2/src/model/RetryJobInstanceResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +RetryJobInstanceResult::RetryJobInstanceResult() : + ServiceResult() +{} + +RetryJobInstanceResult::RetryJobInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RetryJobInstanceResult::~RetryJobInstanceResult() +{} + +void RetryJobInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string RetryJobInstanceResult::getMessage()const +{ + return message_; +} + +int RetryJobInstanceResult::getCode()const +{ + return code_; +} + +bool RetryJobInstanceResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/SetJobInstanceSuccessRequest.cc b/schedulerx2/src/model/SetJobInstanceSuccessRequest.cc new file mode 100644 index 000000000..2542f33cf --- /dev/null +++ b/schedulerx2/src/model/SetJobInstanceSuccessRequest.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::Schedulerx2::Model::SetJobInstanceSuccessRequest; + +SetJobInstanceSuccessRequest::SetJobInstanceSuccessRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "SetJobInstanceSuccess") { + setMethod(HttpRequest::Method::Post); +} + +SetJobInstanceSuccessRequest::~SetJobInstanceSuccessRequest() {} + +std::string SetJobInstanceSuccessRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void SetJobInstanceSuccessRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string SetJobInstanceSuccessRequest::getGroupId() const { + return groupId_; +} + +void SetJobInstanceSuccessRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setParameter(std::string("GroupId"), groupId); +} + +long SetJobInstanceSuccessRequest::getJobId() const { + return jobId_; +} + +void SetJobInstanceSuccessRequest::setJobId(long jobId) { + jobId_ = jobId; + setParameter(std::string("JobId"), std::to_string(jobId)); +} + +std::string SetJobInstanceSuccessRequest::getRegionId() const { + return regionId_; +} + +void SetJobInstanceSuccessRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string SetJobInstanceSuccessRequest::get_Namespace() const { + return _namespace_; +} + +void SetJobInstanceSuccessRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + +long SetJobInstanceSuccessRequest::getJobInstanceId() const { + return jobInstanceId_; +} + +void SetJobInstanceSuccessRequest::setJobInstanceId(long jobInstanceId) { + jobInstanceId_ = jobInstanceId; + setParameter(std::string("JobInstanceId"), std::to_string(jobInstanceId)); +} + diff --git a/schedulerx2/src/model/SetJobInstanceSuccessResult.cc b/schedulerx2/src/model/SetJobInstanceSuccessResult.cc new file mode 100644 index 000000000..9738a0af9 --- /dev/null +++ b/schedulerx2/src/model/SetJobInstanceSuccessResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +SetJobInstanceSuccessResult::SetJobInstanceSuccessResult() : + ServiceResult() +{} + +SetJobInstanceSuccessResult::SetJobInstanceSuccessResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetJobInstanceSuccessResult::~SetJobInstanceSuccessResult() +{} + +void SetJobInstanceSuccessResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string SetJobInstanceSuccessResult::getMessage()const +{ + return message_; +} + +int SetJobInstanceSuccessResult::getCode()const +{ + return code_; +} + +bool SetJobInstanceSuccessResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/SetWfInstanceSuccessRequest.cc b/schedulerx2/src/model/SetWfInstanceSuccessRequest.cc new file mode 100644 index 000000000..d52286c67 --- /dev/null +++ b/schedulerx2/src/model/SetWfInstanceSuccessRequest.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::Schedulerx2::Model::SetWfInstanceSuccessRequest; + +SetWfInstanceSuccessRequest::SetWfInstanceSuccessRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "SetWfInstanceSuccess") { + setMethod(HttpRequest::Method::Post); +} + +SetWfInstanceSuccessRequest::~SetWfInstanceSuccessRequest() {} + +std::string SetWfInstanceSuccessRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void SetWfInstanceSuccessRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string SetWfInstanceSuccessRequest::getGroupId() const { + return groupId_; +} + +void SetWfInstanceSuccessRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setParameter(std::string("GroupId"), groupId); +} + +long SetWfInstanceSuccessRequest::getWfInstanceId() const { + return wfInstanceId_; +} + +void SetWfInstanceSuccessRequest::setWfInstanceId(long wfInstanceId) { + wfInstanceId_ = wfInstanceId; + setParameter(std::string("WfInstanceId"), std::to_string(wfInstanceId)); +} + +std::string SetWfInstanceSuccessRequest::getRegionId() const { + return regionId_; +} + +void SetWfInstanceSuccessRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string SetWfInstanceSuccessRequest::get_Namespace() const { + return _namespace_; +} + +void SetWfInstanceSuccessRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + +long SetWfInstanceSuccessRequest::getWorkflowId() const { + return workflowId_; +} + +void SetWfInstanceSuccessRequest::setWorkflowId(long workflowId) { + workflowId_ = workflowId; + setParameter(std::string("WorkflowId"), std::to_string(workflowId)); +} + diff --git a/schedulerx2/src/model/SetWfInstanceSuccessResult.cc b/schedulerx2/src/model/SetWfInstanceSuccessResult.cc new file mode 100644 index 000000000..3f2d00c82 --- /dev/null +++ b/schedulerx2/src/model/SetWfInstanceSuccessResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +SetWfInstanceSuccessResult::SetWfInstanceSuccessResult() : + ServiceResult() +{} + +SetWfInstanceSuccessResult::SetWfInstanceSuccessResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetWfInstanceSuccessResult::~SetWfInstanceSuccessResult() +{} + +void SetWfInstanceSuccessResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string SetWfInstanceSuccessResult::getMessage()const +{ + return message_; +} + +int SetWfInstanceSuccessResult::getCode()const +{ + return code_; +} + +bool SetWfInstanceSuccessResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/UpdateJobRequest.cc b/schedulerx2/src/model/UpdateJobRequest.cc index d0daa940b..0c2121f0d 100644 --- a/schedulerx2/src/model/UpdateJobRequest.cc +++ b/schedulerx2/src/model/UpdateJobRequest.cc @@ -25,24 +25,6 @@ UpdateJobRequest::UpdateJobRequest() UpdateJobRequest::~UpdateJobRequest() {} -std::string UpdateJobRequest::getNamespaceSource() const { - return namespaceSource_; -} - -void UpdateJobRequest::setNamespaceSource(const std::string &namespaceSource) { - namespaceSource_ = namespaceSource; - setBodyParameter(std::string("NamespaceSource"), namespaceSource); -} - -std::string UpdateJobRequest::getDescription() const { - return description_; -} - -void UpdateJobRequest::setDescription(const std::string &description) { - description_ = description; - setBodyParameter(std::string("Description"), description); -} - int UpdateJobRequest::getAttemptInterval() const { return attemptInterval_; } @@ -52,31 +34,13 @@ void UpdateJobRequest::setAttemptInterval(int attemptInterval) { setBodyParameter(std::string("AttemptInterval"), std::to_string(attemptInterval)); } -std::string UpdateJobRequest::getContent() const { - return content_; +int UpdateJobRequest::getFailTimes() const { + return failTimes_; } -void UpdateJobRequest::setContent(const std::string &content) { - content_ = content; - setBodyParameter(std::string("Content"), content); -} - -long UpdateJobRequest::getTimeout() const { - return timeout_; -} - -void UpdateJobRequest::setTimeout(long timeout) { - timeout_ = timeout; - setBodyParameter(std::string("Timeout"), std::to_string(timeout)); -} - -bool UpdateJobRequest::getTimeoutKillEnable() const { - return timeoutKillEnable_; -} - -void UpdateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable) { - timeoutKillEnable_ = timeoutKillEnable; - setBodyParameter(std::string("TimeoutKillEnable"), timeoutKillEnable ? "true" : "false"); +void UpdateJobRequest::setFailTimes(int failTimes) { + failTimes_ = failTimes; + setBodyParameter(std::string("FailTimes"), std::to_string(failTimes)); } long UpdateJobRequest::getJobId() const { @@ -88,24 +52,6 @@ void UpdateJobRequest::setJobId(long jobId) { setBodyParameter(std::string("JobId"), std::to_string(jobId)); } -std::string UpdateJobRequest::getRegionId() const { - return regionId_; -} - -void UpdateJobRequest::setRegionId(const std::string ®ionId) { - regionId_ = regionId; - setParameter(std::string("RegionId"), regionId); -} - -int UpdateJobRequest::getPageSize() const { - return pageSize_; -} - -void UpdateJobRequest::setPageSize(int pageSize) { - pageSize_ = pageSize; - setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); -} - int UpdateJobRequest::getConsumerSize() const { return consumerSize_; } @@ -124,42 +70,6 @@ void UpdateJobRequest::setJarUrl(const std::string &jarUrl) { setBodyParameter(std::string("JarUrl"), jarUrl); } -std::string UpdateJobRequest::getCalendar() const { - return calendar_; -} - -void UpdateJobRequest::setCalendar(const std::string &calendar) { - calendar_ = calendar; - setBodyParameter(std::string("Calendar"), calendar); -} - -bool UpdateJobRequest::getFailEnable() const { - return failEnable_; -} - -void UpdateJobRequest::setFailEnable(bool failEnable) { - failEnable_ = failEnable; - setBodyParameter(std::string("FailEnable"), failEnable ? "true" : "false"); -} - -std::string UpdateJobRequest::getSendChannel() const { - return sendChannel_; -} - -void UpdateJobRequest::setSendChannel(const std::string &sendChannel) { - sendChannel_ = sendChannel; - setBodyParameter(std::string("SendChannel"), sendChannel); -} - -int UpdateJobRequest::getDataOffset() const { - return dataOffset_; -} - -void UpdateJobRequest::setDataOffset(int dataOffset) { - dataOffset_ = dataOffset; - setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset)); -} - std::string UpdateJobRequest::getGroupId() const { return groupId_; } @@ -178,22 +88,13 @@ void UpdateJobRequest::setTaskMaxAttempt(int taskMaxAttempt) { setBodyParameter(std::string("TaskMaxAttempt"), std::to_string(taskMaxAttempt)); } -int UpdateJobRequest::getMaxAttempt() const { - return maxAttempt_; +int UpdateJobRequest::getDataOffset() const { + return dataOffset_; } -void UpdateJobRequest::setMaxAttempt(int maxAttempt) { - maxAttempt_ = maxAttempt; - setBodyParameter(std::string("MaxAttempt"), std::to_string(maxAttempt)); -} - -bool UpdateJobRequest::getMissWorkerEnable() const { - return missWorkerEnable_; -} - -void UpdateJobRequest::setMissWorkerEnable(bool missWorkerEnable) { - missWorkerEnable_ = missWorkerEnable; - setBodyParameter(std::string("MissWorkerEnable"), missWorkerEnable ? "true" : "false"); +void UpdateJobRequest::setDataOffset(int dataOffset) { + dataOffset_ = dataOffset; + setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset)); } int UpdateJobRequest::getDispatcherSize() const { @@ -223,15 +124,6 @@ void UpdateJobRequest::setExecuteMode(const std::string &executeMode) { setBodyParameter(std::string("ExecuteMode"), executeMode); } -int UpdateJobRequest::getQueueSize() const { - return queueSize_; -} - -void UpdateJobRequest::setQueueSize(int queueSize) { - queueSize_ = queueSize; - setBodyParameter(std::string("QueueSize"), std::to_string(queueSize)); -} - std::string UpdateJobRequest::getTimeExpression() const { return timeExpression_; } @@ -241,15 +133,6 @@ void UpdateJobRequest::setTimeExpression(const std::string &timeExpression) { setBodyParameter(std::string("TimeExpression"), timeExpression); } -std::string UpdateJobRequest::getClassName() const { - return className_; -} - -void UpdateJobRequest::setClassName(const std::string &className) { - className_ = className; - setBodyParameter(std::string("ClassName"), className); -} - bool UpdateJobRequest::getTimeoutEnable() const { return timeoutEnable_; } @@ -284,24 +167,6 @@ void UpdateJobRequest::setName(const std::string &name) { setBodyParameter(std::string("Name"), name); } -std::string UpdateJobRequest::get_Namespace() const { - return _namespace_; -} - -void UpdateJobRequest::set_Namespace(const std::string &_namespace) { - _namespace_ = _namespace; - setBodyParameter(std::string("Namespace"), _namespace); -} - -int UpdateJobRequest::getMaxConcurrency() const { - return maxConcurrency_; -} - -void UpdateJobRequest::setMaxConcurrency(int maxConcurrency) { - maxConcurrency_ = maxConcurrency; - setBodyParameter(std::string("MaxConcurrency"), std::to_string(maxConcurrency)); -} - int UpdateJobRequest::getTimeType() const { return timeType_; } @@ -320,3 +185,156 @@ void UpdateJobRequest::setParameters(const std::string ¶meters) { setBodyParameter(std::string("Parameters"), parameters); } +std::string UpdateJobRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void UpdateJobRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setBodyParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string UpdateJobRequest::getDescription() const { + return description_; +} + +void UpdateJobRequest::setDescription(const std::string &description) { + description_ = description; + setBodyParameter(std::string("Description"), description); +} + +std::string UpdateJobRequest::getContent() const { + return content_; +} + +void UpdateJobRequest::setContent(const std::string &content) { + content_ = content; + setBodyParameter(std::string("Content"), content); +} + +long UpdateJobRequest::getTimeout() const { + return timeout_; +} + +void UpdateJobRequest::setTimeout(long timeout) { + timeout_ = timeout; + setBodyParameter(std::string("Timeout"), std::to_string(timeout)); +} + +bool UpdateJobRequest::getTimeoutKillEnable() const { + return timeoutKillEnable_; +} + +void UpdateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable) { + timeoutKillEnable_ = timeoutKillEnable; + setBodyParameter(std::string("TimeoutKillEnable"), timeoutKillEnable ? "true" : "false"); +} + +std::string UpdateJobRequest::getRegionId() const { + return regionId_; +} + +void UpdateJobRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +int UpdateJobRequest::getPageSize() const { + return pageSize_; +} + +void UpdateJobRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string UpdateJobRequest::getCalendar() const { + return calendar_; +} + +void UpdateJobRequest::setCalendar(const std::string &calendar) { + calendar_ = calendar; + setBodyParameter(std::string("Calendar"), calendar); +} + +bool UpdateJobRequest::getFailEnable() const { + return failEnable_; +} + +void UpdateJobRequest::setFailEnable(bool failEnable) { + failEnable_ = failEnable; + setBodyParameter(std::string("FailEnable"), failEnable ? "true" : "false"); +} + +std::string UpdateJobRequest::getSendChannel() const { + return sendChannel_; +} + +void UpdateJobRequest::setSendChannel(const std::string &sendChannel) { + sendChannel_ = sendChannel; + setBodyParameter(std::string("SendChannel"), sendChannel); +} + +int UpdateJobRequest::getMaxAttempt() const { + return maxAttempt_; +} + +void UpdateJobRequest::setMaxAttempt(int maxAttempt) { + maxAttempt_ = maxAttempt; + setBodyParameter(std::string("MaxAttempt"), std::to_string(maxAttempt)); +} + +bool UpdateJobRequest::getMissWorkerEnable() const { + return missWorkerEnable_; +} + +void UpdateJobRequest::setMissWorkerEnable(bool missWorkerEnable) { + missWorkerEnable_ = missWorkerEnable; + setBodyParameter(std::string("MissWorkerEnable"), missWorkerEnable ? "true" : "false"); +} + +bool UpdateJobRequest::getSuccessNoticeEnable() const { + return successNoticeEnable_; +} + +void UpdateJobRequest::setSuccessNoticeEnable(bool successNoticeEnable) { + successNoticeEnable_ = successNoticeEnable; + setBodyParameter(std::string("SuccessNoticeEnable"), successNoticeEnable ? "true" : "false"); +} + +int UpdateJobRequest::getQueueSize() const { + return queueSize_; +} + +void UpdateJobRequest::setQueueSize(int queueSize) { + queueSize_ = queueSize; + setBodyParameter(std::string("QueueSize"), std::to_string(queueSize)); +} + +std::string UpdateJobRequest::getClassName() const { + return className_; +} + +void UpdateJobRequest::setClassName(const std::string &className) { + className_ = className; + setBodyParameter(std::string("ClassName"), className); +} + +std::string UpdateJobRequest::get_Namespace() const { + return _namespace_; +} + +void UpdateJobRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setBodyParameter(std::string("Namespace"), _namespace); +} + +int UpdateJobRequest::getMaxConcurrency() const { + return maxConcurrency_; +} + +void UpdateJobRequest::setMaxConcurrency(int maxConcurrency) { + maxConcurrency_ = maxConcurrency; + setBodyParameter(std::string("MaxConcurrency"), std::to_string(maxConcurrency)); +} + diff --git a/schedulerx2/src/model/UpdateWorkflowDagRequest.cc b/schedulerx2/src/model/UpdateWorkflowDagRequest.cc new file mode 100644 index 000000000..890ec69c8 --- /dev/null +++ b/schedulerx2/src/model/UpdateWorkflowDagRequest.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::Schedulerx2::Model::UpdateWorkflowDagRequest; + +UpdateWorkflowDagRequest::UpdateWorkflowDagRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "UpdateWorkflowDag") { + setMethod(HttpRequest::Method::Post); +} + +UpdateWorkflowDagRequest::~UpdateWorkflowDagRequest() {} + +std::string UpdateWorkflowDagRequest::getDagJson() const { + return dagJson_; +} + +void UpdateWorkflowDagRequest::setDagJson(const std::string &dagJson) { + dagJson_ = dagJson; + setBodyParameter(std::string("DagJson"), dagJson); +} + +std::string UpdateWorkflowDagRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void UpdateWorkflowDagRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setBodyParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string UpdateWorkflowDagRequest::getGroupId() const { + return groupId_; +} + +void UpdateWorkflowDagRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setBodyParameter(std::string("GroupId"), groupId); +} + +std::string UpdateWorkflowDagRequest::getRegionId() const { + return regionId_; +} + +void UpdateWorkflowDagRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string UpdateWorkflowDagRequest::get_Namespace() const { + return _namespace_; +} + +void UpdateWorkflowDagRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setBodyParameter(std::string("Namespace"), _namespace); +} + +std::string UpdateWorkflowDagRequest::getWorkflowId() const { + return workflowId_; +} + +void UpdateWorkflowDagRequest::setWorkflowId(const std::string &workflowId) { + workflowId_ = workflowId; + setBodyParameter(std::string("WorkflowId"), workflowId); +} + diff --git a/schedulerx2/src/model/UpdateWorkflowDagResult.cc b/schedulerx2/src/model/UpdateWorkflowDagResult.cc new file mode 100644 index 000000000..838dece12 --- /dev/null +++ b/schedulerx2/src/model/UpdateWorkflowDagResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +UpdateWorkflowDagResult::UpdateWorkflowDagResult() : + ServiceResult() +{} + +UpdateWorkflowDagResult::UpdateWorkflowDagResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateWorkflowDagResult::~UpdateWorkflowDagResult() +{} + +void UpdateWorkflowDagResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string UpdateWorkflowDagResult::getMessage()const +{ + return message_; +} + +int UpdateWorkflowDagResult::getCode()const +{ + return code_; +} + +bool UpdateWorkflowDagResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/UpdateWorkflowRequest.cc b/schedulerx2/src/model/UpdateWorkflowRequest.cc new file mode 100644 index 000000000..82c33e47d --- /dev/null +++ b/schedulerx2/src/model/UpdateWorkflowRequest.cc @@ -0,0 +1,108 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Schedulerx2::Model::UpdateWorkflowRequest; + +UpdateWorkflowRequest::UpdateWorkflowRequest() + : RpcServiceRequest("schedulerx2", "2019-04-30", "UpdateWorkflow") { + setMethod(HttpRequest::Method::Post); +} + +UpdateWorkflowRequest::~UpdateWorkflowRequest() {} + +std::string UpdateWorkflowRequest::getNamespaceSource() const { + return namespaceSource_; +} + +void UpdateWorkflowRequest::setNamespaceSource(const std::string &namespaceSource) { + namespaceSource_ = namespaceSource; + setBodyParameter(std::string("NamespaceSource"), namespaceSource); +} + +std::string UpdateWorkflowRequest::getDescription() const { + return description_; +} + +void UpdateWorkflowRequest::setDescription(const std::string &description) { + description_ = description; + setBodyParameter(std::string("Description"), description); +} + +std::string UpdateWorkflowRequest::getRegionId() const { + return regionId_; +} + +void UpdateWorkflowRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string UpdateWorkflowRequest::getWorkflowId() const { + return workflowId_; +} + +void UpdateWorkflowRequest::setWorkflowId(const std::string &workflowId) { + workflowId_ = workflowId; + setBodyParameter(std::string("WorkflowId"), workflowId); +} + +std::string UpdateWorkflowRequest::getGroupId() const { + return groupId_; +} + +void UpdateWorkflowRequest::setGroupId(const std::string &groupId) { + groupId_ = groupId; + setBodyParameter(std::string("GroupId"), groupId); +} + +std::string UpdateWorkflowRequest::getTimeExpression() const { + return timeExpression_; +} + +void UpdateWorkflowRequest::setTimeExpression(const std::string &timeExpression) { + timeExpression_ = timeExpression; + setBodyParameter(std::string("TimeExpression"), timeExpression); +} + +std::string UpdateWorkflowRequest::get_Namespace() const { + return _namespace_; +} + +void UpdateWorkflowRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setBodyParameter(std::string("Namespace"), _namespace); +} + +std::string UpdateWorkflowRequest::getName() const { + return name_; +} + +void UpdateWorkflowRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + +int UpdateWorkflowRequest::getTimeType() const { + return timeType_; +} + +void UpdateWorkflowRequest::setTimeType(int timeType) { + timeType_ = timeType; + setBodyParameter(std::string("TimeType"), std::to_string(timeType)); +} + diff --git a/schedulerx2/src/model/UpdateWorkflowResult.cc b/schedulerx2/src/model/UpdateWorkflowResult.cc new file mode 100644 index 000000000..56f7731d6 --- /dev/null +++ b/schedulerx2/src/model/UpdateWorkflowResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +UpdateWorkflowResult::UpdateWorkflowResult() : + ServiceResult() +{} + +UpdateWorkflowResult::UpdateWorkflowResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateWorkflowResult::~UpdateWorkflowResult() +{} + +void UpdateWorkflowResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string UpdateWorkflowResult::getMessage()const +{ + return message_; +} + +int UpdateWorkflowResult::getCode()const +{ + return code_; +} + +bool UpdateWorkflowResult::getSuccess()const +{ + return success_; +} +