1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Support Create Workflow.

Browse Source
This commit is contained in:
sdk-team
2023-02-10 06:28:15 +00:00
parent 4f44a09488
commit 483be2dd81
56 changed files with 3698 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
schedulerx2/CMakeLists.txt
View File

@@ -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}

80
schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h
View File

@@ -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<Error, Model::CreateNamespaceResult> CreateNamespaceOutcome;
typedef std::future<CreateNamespaceOutcome> CreateNamespaceOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::CreateNamespaceRequest&, const CreateNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNamespaceAsyncHandler;
typedef Outcome<Error, Model::CreateWorkflowResult> CreateWorkflowOutcome;
typedef std::future<CreateWorkflowOutcome> CreateWorkflowOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::CreateWorkflowRequest&, const CreateWorkflowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateWorkflowAsyncHandler;
typedef Outcome<Error, Model::DeleteJobResult> DeleteJobOutcome;
typedef std::future<DeleteJobOutcome> DeleteJobOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::DeleteJobRequest&, const DeleteJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteJobAsyncHandler;
@@ -144,12 +167,18 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetJobInstanceListResult> GetJobInstanceListOutcome;
typedef std::future<GetJobInstanceListOutcome> GetJobInstanceListOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::GetJobInstanceListRequest&, const GetJobInstanceListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetJobInstanceListAsyncHandler;
typedef Outcome<Error, Model::GetLogResult> GetLogOutcome;
typedef std::future<GetLogOutcome> GetLogOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::GetLogRequest&, const GetLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLogAsyncHandler;
typedef Outcome<Error, Model::GetWorkFlowResult> GetWorkFlowOutcome;
typedef std::future<GetWorkFlowOutcome> GetWorkFlowOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::GetWorkFlowRequest&, const GetWorkFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWorkFlowAsyncHandler;
typedef Outcome<Error, Model::GetWorkerListResult> GetWorkerListOutcome;
typedef std::future<GetWorkerListOutcome> GetWorkerListOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::GetWorkerListRequest&, const GetWorkerListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWorkerListAsyncHandler;
typedef Outcome<Error, Model::GetWorkflowInstanceResult> GetWorkflowInstanceOutcome;
typedef std::future<GetWorkflowInstanceOutcome> GetWorkflowInstanceOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::GetWorkflowInstanceRequest&, const GetWorkflowInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWorkflowInstanceAsyncHandler;
typedef Outcome<Error, Model::GrantPermissionResult> GrantPermissionOutcome;
typedef std::future<GrantPermissionOutcome> GrantPermissionOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::GrantPermissionRequest&, const GrantPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrantPermissionAsyncHandler;
@@ -162,15 +191,36 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListNamespacesResult> ListNamespacesOutcome;
typedef std::future<ListNamespacesOutcome> ListNamespacesOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::ListNamespacesRequest&, const ListNamespacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNamespacesAsyncHandler;
typedef Outcome<Error, Model::ListWorkflowInstanceResult> ListWorkflowInstanceOutcome;
typedef std::future<ListWorkflowInstanceOutcome> ListWorkflowInstanceOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::ListWorkflowInstanceRequest&, const ListWorkflowInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListWorkflowInstanceAsyncHandler;
typedef Outcome<Error, Model::RerunJobResult> RerunJobOutcome;
typedef std::future<RerunJobOutcome> RerunJobOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::RerunJobRequest&, const RerunJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RerunJobAsyncHandler;
typedef Outcome<Error, Model::RetryJobInstanceResult> RetryJobInstanceOutcome;
typedef std::future<RetryJobInstanceOutcome> RetryJobInstanceOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::RetryJobInstanceRequest&, const RetryJobInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetryJobInstanceAsyncHandler;
typedef Outcome<Error, Model::RevokePermissionResult> RevokePermissionOutcome;
typedef std::future<RevokePermissionOutcome> RevokePermissionOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::RevokePermissionRequest&, const RevokePermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevokePermissionAsyncHandler;
typedef Outcome<Error, Model::SetJobInstanceSuccessResult> SetJobInstanceSuccessOutcome;
typedef std::future<SetJobInstanceSuccessOutcome> SetJobInstanceSuccessOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::SetJobInstanceSuccessRequest&, const SetJobInstanceSuccessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetJobInstanceSuccessAsyncHandler;
typedef Outcome<Error, Model::SetWfInstanceSuccessResult> SetWfInstanceSuccessOutcome;
typedef std::future<SetWfInstanceSuccessOutcome> SetWfInstanceSuccessOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::SetWfInstanceSuccessRequest&, const SetWfInstanceSuccessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetWfInstanceSuccessAsyncHandler;
typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
typedef Outcome<Error, Model::UpdateJobResult> UpdateJobOutcome;
typedef std::future<UpdateJobOutcome> UpdateJobOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::UpdateJobRequest&, const UpdateJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateJobAsyncHandler;
typedef Outcome<Error, Model::UpdateWorkflowResult> UpdateWorkflowOutcome;
typedef std::future<UpdateWorkflowOutcome> UpdateWorkflowOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::UpdateWorkflowRequest&, const UpdateWorkflowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateWorkflowAsyncHandler;
typedef Outcome<Error, Model::UpdateWorkflowDagResult> UpdateWorkflowDagOutcome;
typedef std::future<UpdateWorkflowDagOutcome> UpdateWorkflowDagOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::UpdateWorkflowDagRequest&, const UpdateWorkflowDagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateWorkflowDagAsyncHandler;
Schedulerx2Client(const Credentials &credentials, const ClientConfiguration &configuration);
Schedulerx2Client(const std::shared_ptr<CredentialsProvider> &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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& context = nullptr) const;
UpdateWorkflowDagOutcomeCallable updateWorkflowDagCallable(const Model::UpdateWorkflowDagRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

3
schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h
View File

@@ -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_;

12
schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h
View File

@@ -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_;

69
schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

61
schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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_

3
schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h
View File

@@ -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 &regionId);
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_;

9
schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h
View File

@@ -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 &regionId);
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

75
schedulerx2/include/alibabacloud/schedulerx2/model/GetLogRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

61
schedulerx2/include/alibabacloud/schedulerx2/model/GetLogResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT GetLogResult : public ServiceResult
{
public:
struct Data
{
std::vector<std::string> 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_

57
schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

92
schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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<Edge> edges;
std::vector<Node> 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_

1
schedulerx2/include/alibabacloud/schedulerx2/model/ListGroupsResult.h
View File

@@ -37,6 +37,7 @@ namespace AlibabaCloud
struct AppGroup
{
std::string description;
long appGroupId;
std::string appKey;
std::string appName;
std::string groupId;

54
schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

71
schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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<WfInstanceInfosItem> 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_

63
schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

55
schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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_

57
schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

55
schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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_

57
schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

55
schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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_

57
schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

55
schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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_

108
schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h
View File

@@ -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 &regionId);
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<ContactInfo> getContactInfo() const;
void setContactInfo(const std::vector<ContactInfo> &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 &parameters);
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 &regionId);
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> 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

57
schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

55
schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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_

66
schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowRequest.h Normal file
View File

@@ -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 <alibabacloud/schedulerx2/Schedulerx2Export.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

55
schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
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_

360
schedulerx2/src/Schedulerx2Client.cc
View File

@@ -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<const AsyncCallerContext>& 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<std::packaged_task<CreateWorkflowOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<GetLogOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<GetWorkflowInstanceOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<ListWorkflowInstanceOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<RerunJobOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<RetryJobInstanceOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<SetJobInstanceSuccessOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<SetWfInstanceSuccessOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<UpdateWorkflowOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<UpdateWorkflowDagOutcome()>>(
[this, request]()
{
return this->updateWorkflowDag(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

9
schedulerx2/src/model/CreateAppGroupRequest.cc
View File

@@ -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_;
}

36
schedulerx2/src/model/CreateJobRequest.cc
View File

@@ -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_;
}

117
schedulerx2/src/model/CreateWorkflowRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/CreateWorkflowRequest.h>
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 &regionId) {
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));
}

73
schedulerx2/src/model/CreateWorkflowResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/CreateWorkflowResult.h>
#include <json/json.h>
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_;
}

9
schedulerx2/src/model/ExecuteWorkflowRequest.cc
View File

@@ -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 &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string ExecuteWorkflowRequest::get_Namespace() const {
return _namespace_;
}

27
schedulerx2/src/model/GetJobInstanceListRequest.cc
View File

@@ -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));
}

135
schedulerx2/src/model/GetLogRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/GetLogRequest.h>
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 &regionId) {
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);
}

74
schedulerx2/src/model/GetLogResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/GetLogResult.h>
#include <json/json.h>
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_;
}

81
schedulerx2/src/model/GetWorkflowInstanceRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.h>
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 &regionId) {
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));
}

117
schedulerx2/src/model/GetWorkflowInstanceResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/GetWorkflowInstanceResult.h>
#include <json/json.h>
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_;
}

2
schedulerx2/src/model/ListGroupsResult.cc
View File

@@ -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())

72
schedulerx2/src/model/ListWorkflowInstanceRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.h>
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 &regionId) {
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);
}

91
schedulerx2/src/model/ListWorkflowInstanceResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/ListWorkflowInstanceResult.h>
#include <json/json.h>
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_;
}

99
schedulerx2/src/model/RerunJobRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/RerunJobRequest.h>
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 &regionId) {
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);
}

65
schedulerx2/src/model/RerunJobResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/RerunJobResult.h>
#include <json/json.h>
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_;
}

81
schedulerx2/src/model/RetryJobInstanceRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/RetryJobInstanceRequest.h>
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 &regionId) {
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));
}

65
schedulerx2/src/model/RetryJobInstanceResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/RetryJobInstanceResult.h>
#include <json/json.h>
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_;
}

81
schedulerx2/src/model/SetJobInstanceSuccessRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.h>
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 &regionId) {
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));
}

65
schedulerx2/src/model/SetJobInstanceSuccessResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/SetJobInstanceSuccessResult.h>
#include <json/json.h>
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_;
}

81
schedulerx2/src/model/SetWfInstanceSuccessRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.h>
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 &regionId) {
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));
}

65
schedulerx2/src/model/SetWfInstanceSuccessResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/SetWfInstanceSuccessResult.h>
#include <json/json.h>
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_;
}

308
schedulerx2/src/model/UpdateJobRequest.cc
View File

@@ -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 &regionId) {
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 &parameters) {
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 &regionId) {
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));
}

81
schedulerx2/src/model/UpdateWorkflowDagRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.h>
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 &regionId) {
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);
}

65
schedulerx2/src/model/UpdateWorkflowDagResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/UpdateWorkflowDagResult.h>
#include <json/json.h>
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_;
}

108
schedulerx2/src/model/UpdateWorkflowRequest.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/UpdateWorkflowRequest.h>
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 &regionId) {
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));
}

65
schedulerx2/src/model/UpdateWorkflowResult.cc Normal file
View File

@@ -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 <alibabacloud/schedulerx2/model/UpdateWorkflowResult.h>
#include <json/json.h>
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_;
}