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

Supported Designate Workers.

Browse Source
This commit is contained in:
sdk-team
2021-12-21 04:13:21 +00:00
parent 52cbb112ba
commit 42e485b31a
82 changed files with 3306 additions and 3127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG
View File

@@ -1,3 +1,7 @@
2021-12-21 Version: 1.36.987
- Supported Designate Workers.
- Supported Get WorkFlow.
2021-12-20 Version: 1.36.986
- Add Request Param Ipv6AddressCount For API CreateLaunchTemplate AND CreateLaunchTemplateVersion.
- Add Response Data Ipv6AddressCount For API DescribeLaunchTemplateVersions.

2
VERSION
View File

@@ -1 +1 @@
1.36.986
1.36.987

8
schedulerx2/CMakeLists.txt
View File

@@ -37,6 +37,8 @@ set(schedulerx2_public_header_model
include/alibabacloud/schedulerx2/model/DeleteWorkflowResult.h
include/alibabacloud/schedulerx2/model/DescribeRegionsRequest.h
include/alibabacloud/schedulerx2/model/DescribeRegionsResult.h
include/alibabacloud/schedulerx2/model/DesignateWorkersRequest.h
include/alibabacloud/schedulerx2/model/DesignateWorkersResult.h
include/alibabacloud/schedulerx2/model/DisableJobRequest.h
include/alibabacloud/schedulerx2/model/DisableJobResult.h
include/alibabacloud/schedulerx2/model/DisableWorkflowRequest.h
@@ -55,6 +57,8 @@ 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/GetWorkFlowRequest.h
include/alibabacloud/schedulerx2/model/GetWorkFlowResult.h
include/alibabacloud/schedulerx2/model/GrantPermissionRequest.h
include/alibabacloud/schedulerx2/model/GrantPermissionResult.h
include/alibabacloud/schedulerx2/model/ListGroupsRequest.h
@@ -88,6 +92,8 @@ set(schedulerx2_src
src/model/DeleteWorkflowResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/DesignateWorkersRequest.cc
src/model/DesignateWorkersResult.cc
src/model/DisableJobRequest.cc
src/model/DisableJobResult.cc
src/model/DisableWorkflowRequest.cc
@@ -106,6 +112,8 @@ set(schedulerx2_src
src/model/GetJobInstanceResult.cc
src/model/GetJobInstanceListRequest.cc
src/model/GetJobInstanceListResult.cc
src/model/GetWorkFlowRequest.cc
src/model/GetWorkFlowResult.cc
src/model/GrantPermissionRequest.cc
src/model/GrantPermissionResult.cc
src/model/ListGroupsRequest.cc

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

@@ -38,6 +38,8 @@
#include "model/DeleteWorkflowResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DesignateWorkersRequest.h"
#include "model/DesignateWorkersResult.h"
#include "model/DisableJobRequest.h"
#include "model/DisableJobResult.h"
#include "model/DisableWorkflowRequest.h"
@@ -56,6 +58,8 @@
#include "model/GetJobInstanceResult.h"
#include "model/GetJobInstanceListRequest.h"
#include "model/GetJobInstanceListResult.h"
#include "model/GetWorkFlowRequest.h"
#include "model/GetWorkFlowResult.h"
#include "model/GrantPermissionRequest.h"
#include "model/GrantPermissionResult.h"
#include "model/ListGroupsRequest.h"
@@ -103,6 +107,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DesignateWorkersResult> DesignateWorkersOutcome;
typedef std::future<DesignateWorkersOutcome> DesignateWorkersOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::DesignateWorkersRequest&, const DesignateWorkersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DesignateWorkersAsyncHandler;
typedef Outcome<Error, Model::DisableJobResult> DisableJobOutcome;
typedef std::future<DisableJobOutcome> DisableJobOutcomeCallable;
typedef std::function<void(const Schedulerx2Client*, const Model::DisableJobRequest&, const DisableJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableJobAsyncHandler;
@@ -130,6 +137,9 @@ 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::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::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;
@@ -180,6 +190,9 @@ namespace AlibabaCloud
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
DesignateWorkersOutcome designateWorkers(const Model::DesignateWorkersRequest &request)const;
void designateWorkersAsync(const Model::DesignateWorkersRequest& request, const DesignateWorkersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DesignateWorkersOutcomeCallable designateWorkersCallable(const Model::DesignateWorkersRequest& request) const;
DisableJobOutcome disableJob(const Model::DisableJobRequest &request)const;
void disableJobAsync(const Model::DisableJobRequest& request, const DisableJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableJobOutcomeCallable disableJobCallable(const Model::DisableJobRequest& request) const;
@@ -207,6 +220,9 @@ 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;
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;
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;

92
schedulerx2/include/alibabacloud/schedulerx2/model/BatchDeleteJobsRequest.h
View File

@@ -1,60 +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_BATCHDELETEJOBSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDELETEJOBSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT BatchDeleteJobsRequest : public RpcServiceRequest
{
public:
BatchDeleteJobsRequest();
~BatchDeleteJobsRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::vector<long> getJobIdList()const;
void setJobIdList(const std::vector<long>& jobIdList);
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 groupId_;
std::vector<long> jobIdList_;
std::string regionId_;
std::string _namespace_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDELETEJOBSREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDELETEJOBSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDELETEJOBSREQUEST_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 BatchDeleteJobsRequest : public RpcServiceRequest {
public:
BatchDeleteJobsRequest();
~BatchDeleteJobsRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::vector<long> getJobIdList() const;
void setJobIdList(const std::vector<long> &jobIdList);
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 groupId_;
std::vector<long> jobIdList_;
std::string regionId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDELETEJOBSREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/BatchDisableJobsRequest.h
View File

@@ -1,60 +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_BATCHDISABLEJOBSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDISABLEJOBSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT BatchDisableJobsRequest : public RpcServiceRequest
{
public:
BatchDisableJobsRequest();
~BatchDisableJobsRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
std::vector<long> getJobIdList()const;
void setJobIdList(const std::vector<long>& jobIdList);
private:
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::vector<long> jobIdList_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDISABLEJOBSREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDISABLEJOBSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDISABLEJOBSREQUEST_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 BatchDisableJobsRequest : public RpcServiceRequest {
public:
BatchDisableJobsRequest();
~BatchDisableJobsRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
std::vector<long> getJobIdList() const;
void setJobIdList(const std::vector<long> &jobIdList);
private:
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::vector<long> jobIdList_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHDISABLEJOBSREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/BatchEnableJobsRequest.h
View File

@@ -1,60 +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_BATCHENABLEJOBSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHENABLEJOBSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT BatchEnableJobsRequest : public RpcServiceRequest
{
public:
BatchEnableJobsRequest();
~BatchEnableJobsRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
std::vector<long> getJobIdList()const;
void setJobIdList(const std::vector<long>& jobIdList);
private:
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::vector<long> jobIdList_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHENABLEJOBSREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHENABLEJOBSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHENABLEJOBSREQUEST_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 BatchEnableJobsRequest : public RpcServiceRequest {
public:
BatchEnableJobsRequest();
~BatchEnableJobsRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
std::vector<long> getJobIdList() const;
void setJobIdList(const std::vector<long> &jobIdList);
private:
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::vector<long> jobIdList_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_BATCHENABLEJOBSREQUEST_H_

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

@@ -1,75 +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_CREATEAPPGROUPREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateAppGroupRequest : public RpcServiceRequest
{
public:
CreateAppGroupRequest();
~CreateAppGroupRequest();
int getMaxJobs()const;
void setMaxJobs(int maxJobs);
std::string getNamespaceName()const;
void setNamespaceName(const std::string& namespaceName);
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getMetricsThresholdJson()const;
void setMetricsThresholdJson(const std::string& metricsThresholdJson);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
std::string getAlarmJson()const;
void setAlarmJson(const std::string& alarmJson);
private:
int maxJobs_;
std::string namespaceName_;
std::string namespaceSource_;
std::string metricsThresholdJson_;
std::string groupId_;
std::string description_;
std::string appName_;
std::string regionId_;
std::string _namespace_;
std::string alarmJson_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPREQUEST_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 CreateAppGroupRequest : public RpcServiceRequest {
public:
CreateAppGroupRequest();
~CreateAppGroupRequest();
int getMaxJobs() const;
void setMaxJobs(int maxJobs);
std::string getNamespaceName() const;
void setNamespaceName(const std::string &namespaceName);
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getMetricsThresholdJson() const;
void setMetricsThresholdJson(const std::string &metricsThresholdJson);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getAppName() const;
void setAppName(const std::string &appName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
std::string getAlarmJson() const;
void setAlarmJson(const std::string &alarmJson);
private:
int maxJobs_;
std::string namespaceName_;
std::string namespaceSource_;
std::string metricsThresholdJson_;
std::string groupId_;
std::string description_;
std::string appName_;
std::string regionId_;
std::string _namespace_;
std::string alarmJson_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPREQUEST_H_

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

@@ -1,144 +1,136 @@
/*
* 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_CREATEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateJobRequest : public RpcServiceRequest
{
public:
struct ContactInfo
{
std::string userPhone;
std::string userName;
};
public:
CreateJobRequest();
~CreateJobRequest();
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);
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);
int getDispatcherSize()const;
void setDispatcherSize(int dispatcherSize);
std::string getJobType()const;
void setJobType(const std::string& jobType);
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);
private:
std::string namespaceSource_;
std::string description_;
int attemptInterval_;
std::string content_;
long timeout_;
bool timeoutKillEnable_;
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_;
int dispatcherSize_;
std::string jobType_;
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_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBREQUEST_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 CreateJobRequest : public RpcServiceRequest {
public:
struct ContactInfo {
std::string userPhone;
std::string userName;
};
CreateJobRequest();
~CreateJobRequest();
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);
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);
int getDispatcherSize() const;
void setDispatcherSize(int dispatcherSize);
std::string getJobType() const;
void setJobType(const std::string &jobType);
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);
private:
std::string namespaceSource_;
std::string description_;
int attemptInterval_;
std::string content_;
long timeout_;
bool timeoutKillEnable_;
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_;
int dispatcherSize_;
std::string jobType_;
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_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/DeleteJobRequest.h
View File

@@ -1,60 +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_DELETEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT DeleteJobRequest : public RpcServiceRequest
{
public:
DeleteJobRequest();
~DeleteJobRequest();
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);
private:
std::string namespaceSource_;
std::string groupId_;
long jobId_;
std::string regionId_;
std::string _namespace_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBREQUEST_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 DeleteJobRequest : public RpcServiceRequest {
public:
DeleteJobRequest();
~DeleteJobRequest();
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);
private:
std::string namespaceSource_;
std::string groupId_;
long jobId_;
std::string regionId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/DeleteWorkflowRequest.h
View File

@@ -1,60 +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_DELETEWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT DeleteWorkflowRequest : public RpcServiceRequest
{
public:
DeleteWorkflowRequest();
~DeleteWorkflowRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
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 regionId_;
std::string groupId_;
std::string _namespace_;
long workflowId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWREQUEST_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 DeleteWorkflowRequest : public RpcServiceRequest {
public:
DeleteWorkflowRequest();
~DeleteWorkflowRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
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 regionId_;
std::string groupId_;
std::string _namespace_;
long workflowId_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWREQUEST_H_

62
schedulerx2/include/alibabacloud/schedulerx2/model/DescribeRegionsRequest.h
View File

@@ -1,45 +1,39 @@
/*
* 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_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
private:
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSREQUEST_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 DescribeRegionsRequest : public RpcServiceRequest {
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
private:
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSREQUEST_H_

66
schedulerx2/include/alibabacloud/schedulerx2/model/DesignateWorkersRequest.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_DESIGNATEWORKERSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DESIGNATEWORKERSREQUEST_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 DesignateWorkersRequest : public RpcServiceRequest {
public:
DesignateWorkersRequest();
~DesignateWorkersRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
bool getTransferable() const;
void setTransferable(bool transferable);
std::string getLabels() const;
void setLabels(const std::string &labels);
int getDesignateType() const;
void setDesignateType(int designateType);
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);
std::string getWorkers() const;
void setWorkers(const std::string &workers);
private:
std::string namespaceSource_;
std::string groupId_;
bool transferable_;
std::string labels_;
int designateType_;
long jobId_;
std::string regionId_;
std::string _namespace_;
std::string workers_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DESIGNATEWORKERSREQUEST_H_

55
schedulerx2/include/alibabacloud/schedulerx2/model/DesignateWorkersResult.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_DESIGNATEWORKERSRESULT_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DESIGNATEWORKERSRESULT_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 DesignateWorkersResult : public ServiceResult
{
public:
DesignateWorkersResult();
explicit DesignateWorkersResult(const std::string &payload);
~DesignateWorkersResult();
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_DESIGNATEWORKERSRESULT_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/DisableJobRequest.h
View File

@@ -1,60 +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_DISABLEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT DisableJobRequest : public RpcServiceRequest
{
public:
DisableJobRequest();
~DisableJobRequest();
long getJobId()const;
void setJobId(long jobId);
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBREQUEST_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 DisableJobRequest : public RpcServiceRequest {
public:
DisableJobRequest();
~DisableJobRequest();
long getJobId() const;
void setJobId(long jobId);
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/DisableWorkflowRequest.h
View File

@@ -1,60 +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_DISABLEWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT DisableWorkflowRequest : public RpcServiceRequest
{
public:
DisableWorkflowRequest();
~DisableWorkflowRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
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 regionId_;
std::string groupId_;
std::string _namespace_;
long workflowId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWREQUEST_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 DisableWorkflowRequest : public RpcServiceRequest {
public:
DisableWorkflowRequest();
~DisableWorkflowRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
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 regionId_;
std::string groupId_;
std::string _namespace_;
long workflowId_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/EnableJobRequest.h
View File

@@ -1,60 +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_ENABLEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT EnableJobRequest : public RpcServiceRequest
{
public:
EnableJobRequest();
~EnableJobRequest();
long getJobId()const;
void setJobId(long jobId);
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBREQUEST_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 EnableJobRequest : public RpcServiceRequest {
public:
EnableJobRequest();
~EnableJobRequest();
long getJobId() const;
void setJobId(long jobId);
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/EnableWorkflowRequest.h
View File

@@ -1,60 +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_ENABLEWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT EnableWorkflowRequest : public RpcServiceRequest
{
public:
EnableWorkflowRequest();
~EnableWorkflowRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
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 regionId_;
std::string groupId_;
std::string _namespace_;
long workflowId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWREQUEST_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 EnableWorkflowRequest : public RpcServiceRequest {
public:
EnableWorkflowRequest();
~EnableWorkflowRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
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 regionId_;
std::string groupId_;
std::string _namespace_;
long workflowId_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWREQUEST_H_

101
schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteJobRequest.h
View File

@@ -1,63 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT ExecuteJobRequest : public RpcServiceRequest
{
public:
ExecuteJobRequest();
~ExecuteJobRequest();
long getJobId()const;
void setJobId(long jobId);
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
std::string getInstanceParameters()const;
void setInstanceParameters(const std::string& instanceParameters);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::string instanceParameters_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_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 ExecuteJobRequest : public RpcServiceRequest {
public:
ExecuteJobRequest();
~ExecuteJobRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
bool getCheckJobStatus() const;
void setCheckJobStatus(bool checkJobStatus);
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);
std::string getInstanceParameters() const;
void setInstanceParameters(const std::string &instanceParameters);
private:
std::string namespaceSource_;
bool checkJobStatus_;
std::string groupId_;
long jobId_;
std::string regionId_;
std::string _namespace_;
std::string instanceParameters_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_H_

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

@@ -1,60 +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_EXECUTEWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT ExecuteWorkflowRequest : public RpcServiceRequest
{
public:
ExecuteWorkflowRequest();
~ExecuteWorkflowRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
long getWorkflowId()const;
void setWorkflowId(long workflowId);
std::string getInstanceParameters()const;
void setInstanceParameters(const std::string& instanceParameters);
private:
std::string namespaceSource_;
std::string groupId_;
std::string _namespace_;
long workflowId_;
std::string instanceParameters_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWREQUEST_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 ExecuteWorkflowRequest : public RpcServiceRequest {
public:
ExecuteWorkflowRequest();
~ExecuteWorkflowRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
long getWorkflowId() const;
void setWorkflowId(long workflowId);
std::string getInstanceParameters() const;
void setInstanceParameters(const std::string &instanceParameters);
private:
std::string namespaceSource_;
std::string groupId_;
std::string _namespace_;
long workflowId_;
std::string instanceParameters_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInfoRequest.h
View File

@@ -1,60 +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_GETJOBINFOREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInfoRequest : public RpcServiceRequest
{
public:
GetJobInfoRequest();
~GetJobInfoRequest();
long getJobId()const;
void setJobId(long jobId);
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFOREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFOREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFOREQUEST_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 GetJobInfoRequest : public RpcServiceRequest {
public:
GetJobInfoRequest();
~GetJobInfoRequest();
long getJobId() const;
void setJobId(long jobId);
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFOREQUEST_H_

4
schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInfoResult.h
View File

@@ -40,8 +40,8 @@ namespace AlibabaCloud
{
int taskAttemptInterval;
int queueSize;
int pageSize;
int dispatcherSize;
int pageSize;
int taskMaxAttempt;
int consumerSize;
};
@@ -72,8 +72,8 @@ namespace AlibabaCloud
};
int status;
int maxAttempt;
std::string description;
std::string parameters;
std::string description;
std::string jarUrl;
std::string maxConcurrency;
TimeConfig timeConfig;

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

@@ -1,60 +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_GETJOBINSTANCELISTREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInstanceListRequest : public RpcServiceRequest
{
public:
GetJobInstanceListRequest();
~GetJobInstanceListRequest();
long getJobId()const;
void setJobId(long jobId);
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTREQUEST_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 GetJobInstanceListRequest : public RpcServiceRequest {
public:
GetJobInstanceListRequest();
~GetJobInstanceListRequest();
long getJobId() const;
void setJobId(long jobId);
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
long jobId_;
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceRequest.h
View File

@@ -1,60 +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_GETJOBINSTANCEREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInstanceRequest : public RpcServiceRequest
{
public:
GetJobInstanceRequest();
~GetJobInstanceRequest();
long getJobId()const;
void setJobId(long jobId);
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
long getJobInstanceId()const;
void setJobInstanceId(long jobInstanceId);
private:
long jobId_;
std::string namespaceSource_;
std::string groupId_;
std::string _namespace_;
long jobInstanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCEREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCEREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCEREQUEST_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 GetJobInstanceRequest : public RpcServiceRequest {
public:
GetJobInstanceRequest();
~GetJobInstanceRequest();
long getJobId() const;
void setJobId(long jobId);
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
long getJobInstanceId() const;
void setJobInstanceId(long jobInstanceId);
private:
long jobId_;
std::string namespaceSource_;
std::string groupId_;
std::string _namespace_;
long jobInstanceId_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCEREQUEST_H_

54
schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkFlowRequest.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_GETWORKFLOWREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWREQUEST_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 GetWorkFlowRequest : public RpcServiceRequest {
public:
GetWorkFlowRequest();
~GetWorkFlowRequest();
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);
long getWorkflowId() const;
void setWorkflowId(long workflowId);
private:
std::string namespaceSource_;
std::string groupId_;
std::string regionId_;
std::string _namespace_;
long workflowId_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWREQUEST_H_

87
schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkFlowResult.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* 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_GETWORKFLOWRESULT_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWRESULT_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 GetWorkFlowResult : public ServiceResult
{
public:
struct Data
{
struct WorkFlowInfo
{
std::string status;
std::string description;
std::string timeExpression;
long workflowId;
std::string name;
std::string timeType;
};
struct WorkFlowNodeInfo
{
struct Node
{
int status;
std::string label;
long id;
};
struct Edge
{
long target;
long source;
};
std::vector<Edge> edges;
std::vector<Node> nodes;
};
WorkFlowNodeInfo workFlowNodeInfo;
WorkFlowInfo workFlowInfo;
};
GetWorkFlowResult();
explicit GetWorkFlowResult(const std::string &payload);
~GetWorkFlowResult();
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_GETWORKFLOWRESULT_H_

104
schedulerx2/include/alibabacloud/schedulerx2/model/GrantPermissionRequest.h
View File

@@ -1,66 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT GrantPermissionRequest : public RpcServiceRequest
{
public:
GrantPermissionRequest();
~GrantPermissionRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string getUserId()const;
void setUserId(const std::string& userId);
bool getGrantOption()const;
void setGrantOption(bool grantOption);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
std::string getUserName()const;
void setUserName(const std::string& userName);
private:
std::string namespaceSource_;
std::string groupId_;
std::string userId_;
bool grantOption_;
std::string regionId_;
std::string _namespace_;
std::string userName_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_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 GrantPermissionRequest : public RpcServiceRequest {
public:
GrantPermissionRequest();
~GrantPermissionRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string getUserId() const;
void setUserId(const std::string &userId);
bool getGrantOption() const;
void setGrantOption(bool grantOption);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
std::string getUserName() const;
void setUserName(const std::string &userName);
private:
std::string namespaceSource_;
std::string groupId_;
std::string userId_;
bool grantOption_;
std::string regionId_;
std::string _namespace_;
std::string userName_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_H_

80
schedulerx2/include/alibabacloud/schedulerx2/model/ListGroupsRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_LISTGROUPSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTGROUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT ListGroupsRequest : public RpcServiceRequest
{
public:
ListGroupsRequest();
~ListGroupsRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
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 regionId_;
std::string _namespace_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTGROUPSREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_LISTGROUPSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTGROUPSREQUEST_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 ListGroupsRequest : public RpcServiceRequest {
public:
ListGroupsRequest();
~ListGroupsRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
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 regionId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTGROUPSREQUEST_H_

98
schedulerx2/include/alibabacloud/schedulerx2/model/ListJobsRequest.h
View File

@@ -1,63 +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_LISTJOBSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTJOBSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT ListJobsRequest : public RpcServiceRequest
{
public:
ListJobsRequest();
~ListJobsRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
std::string getJobName()const;
void setJobName(const std::string& jobName);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::string jobName_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTJOBSREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_LISTJOBSREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTJOBSREQUEST_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 ListJobsRequest : public RpcServiceRequest {
public:
ListJobsRequest();
~ListJobsRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
std::string getJobName() const;
void setJobName(const std::string &jobName);
std::string getStatus() const;
void setStatus(const std::string &status);
private:
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::string jobName_;
std::string status_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTJOBSREQUEST_H_

4
schedulerx2/include/alibabacloud/schedulerx2/model/ListJobsResult.h
View File

@@ -40,8 +40,8 @@ namespace AlibabaCloud
{
int taskAttemptInterval;
int queueSize;
int pageSize;
int dispatcherSize;
int pageSize;
int taskMaxAttempt;
int consumerSize;
};
@@ -72,8 +72,8 @@ namespace AlibabaCloud
};
int status;
int maxAttempt;
std::string description;
std::string parameters;
std::string description;
std::string jarUrl;
std::string maxConcurrency;
TimeConfig timeConfig;

68
schedulerx2/include/alibabacloud/schedulerx2/model/ListNamespacesRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_LISTNAMESPACESREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTNAMESPACESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT ListNamespacesRequest : public RpcServiceRequest
{
public:
ListNamespacesRequest();
~ListNamespacesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTNAMESPACESREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_LISTNAMESPACESREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTNAMESPACESREQUEST_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 ListNamespacesRequest : public RpcServiceRequest {
public:
ListNamespacesRequest();
~ListNamespacesRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string regionId_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTNAMESPACESREQUEST_H_

92
schedulerx2/include/alibabacloud/schedulerx2/model/RevokePermissionRequest.h
View File

@@ -1,60 +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_REVOKEPERMISSIONREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT RevokePermissionRequest : public RpcServiceRequest
{
public:
RevokePermissionRequest();
~RevokePermissionRequest();
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
std::string getUserId()const;
void setUserId(const std::string& userId);
private:
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::string userId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONREQUEST_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 RevokePermissionRequest : public RpcServiceRequest {
public:
RevokePermissionRequest();
~RevokePermissionRequest();
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
std::string getUserId() const;
void setUserId(const std::string &userId);
private:
std::string namespaceSource_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
std::string userId_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONREQUEST_H_

98
schedulerx2/include/alibabacloud/schedulerx2/model/StopInstanceRequest.h
View File

@@ -1,63 +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_STOPINSTANCEREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT StopInstanceRequest : public RpcServiceRequest
{
public:
StopInstanceRequest();
~StopInstanceRequest();
long getJobId()const;
void setJobId(long jobId);
std::string getNamespaceSource()const;
void setNamespaceSource(const std::string& namespaceSource);
long getInstanceId()const;
void setInstanceId(long instanceId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string get_Namespace()const;
void set_Namespace(const std::string& _namespace);
private:
long jobId_;
std::string namespaceSource_;
long instanceId_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCEREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCEREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCEREQUEST_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 StopInstanceRequest : public RpcServiceRequest {
public:
StopInstanceRequest();
~StopInstanceRequest();
long getJobId() const;
void setJobId(long jobId);
std::string getNamespaceSource() const;
void setNamespaceSource(const std::string &namespaceSource);
long getInstanceId() const;
void setInstanceId(long instanceId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
long jobId_;
std::string namespaceSource_;
long instanceId_;
std::string regionId_;
std::string groupId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCEREQUEST_H_

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

@@ -1,144 +1,136 @@
/*
* 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_UPDATEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
namespace AlibabaCloud
{
namespace Schedulerx2
{
namespace Model
{
class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateJobRequest : public RpcServiceRequest
{
public:
struct ContactInfo
{
std::string userPhone;
std::string userName;
};
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);
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);
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);
private:
std::string namespaceSource_;
std::string description_;
int attemptInterval_;
std::string content_;
long timeout_;
bool timeoutKillEnable_;
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_;
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_;
};
}
}
}
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBREQUEST_H_
*/
#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBREQUEST_H_
#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBREQUEST_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 UpdateJobRequest : public RpcServiceRequest {
public:
struct ContactInfo {
std::string userPhone;
std::string userName;
};
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);
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);
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);
private:
std::string namespaceSource_;
std::string description_;
int attemptInterval_;
std::string content_;
long timeout_;
bool timeoutKillEnable_;
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_;
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_;
};
} // namespace Model
} // namespace Schedulerx2
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBREQUEST_H_

72
schedulerx2/src/Schedulerx2Client.cc
View File

@@ -339,6 +339,42 @@ Schedulerx2Client::DescribeRegionsOutcomeCallable Schedulerx2Client::describeReg
return task->get_future();
}
Schedulerx2Client::DesignateWorkersOutcome Schedulerx2Client::designateWorkers(const DesignateWorkersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DesignateWorkersOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DesignateWorkersOutcome(DesignateWorkersResult(outcome.result()));
else
return DesignateWorkersOutcome(outcome.error());
}
void Schedulerx2Client::designateWorkersAsync(const DesignateWorkersRequest& request, const DesignateWorkersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, designateWorkers(request), context);
};
asyncExecute(new Runnable(fn));
}
Schedulerx2Client::DesignateWorkersOutcomeCallable Schedulerx2Client::designateWorkersCallable(const DesignateWorkersRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DesignateWorkersOutcome()>>(
[this, request]()
{
return this->designateWorkers(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Schedulerx2Client::DisableJobOutcome Schedulerx2Client::disableJob(const DisableJobRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -663,6 +699,42 @@ Schedulerx2Client::GetJobInstanceListOutcomeCallable Schedulerx2Client::getJobIn
return task->get_future();
}
Schedulerx2Client::GetWorkFlowOutcome Schedulerx2Client::getWorkFlow(const GetWorkFlowRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetWorkFlowOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetWorkFlowOutcome(GetWorkFlowResult(outcome.result()));
else
return GetWorkFlowOutcome(outcome.error());
}
void Schedulerx2Client::getWorkFlowAsync(const GetWorkFlowRequest& request, const GetWorkFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getWorkFlow(request), context);
};
asyncExecute(new Runnable(fn));
}
Schedulerx2Client::GetWorkFlowOutcomeCallable Schedulerx2Client::getWorkFlowCallable(const GetWorkFlowRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetWorkFlowOutcome()>>(
[this, request]()
{
return this->getWorkFlow(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Schedulerx2Client::GrantPermissionOutcome Schedulerx2Client::grantPermission(const GrantPermissionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

95
schedulerx2/src/model/BatchDeleteJobsRequest.cc
View File

@@ -1,86 +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.
*/
#include <alibabacloud/schedulerx2/model/BatchDeleteJobsRequest.h>
using AlibabaCloud::Schedulerx2::Model::BatchDeleteJobsRequest;
BatchDeleteJobsRequest::BatchDeleteJobsRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "BatchDeleteJobs")
{
setMethod(HttpRequest::Method::Post);
}
BatchDeleteJobsRequest::~BatchDeleteJobsRequest()
{}
std::string BatchDeleteJobsRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/BatchDeleteJobsRequest.h>
using AlibabaCloud::Schedulerx2::Model::BatchDeleteJobsRequest;
BatchDeleteJobsRequest::BatchDeleteJobsRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "BatchDeleteJobs") {
setMethod(HttpRequest::Method::Post);
}
void BatchDeleteJobsRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
BatchDeleteJobsRequest::~BatchDeleteJobsRequest() {}
std::string BatchDeleteJobsRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string BatchDeleteJobsRequest::getGroupId()const
{
return groupId_;
void BatchDeleteJobsRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void BatchDeleteJobsRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string BatchDeleteJobsRequest::getGroupId() const {
return groupId_;
}
std::vector<long> BatchDeleteJobsRequest::getJobIdList()const
{
return jobIdList_;
void BatchDeleteJobsRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void BatchDeleteJobsRequest::setJobIdList(const std::vector<long>& jobIdList)
{
jobIdList_ = jobIdList;
for(int dep1 = 0; dep1!= jobIdList.size(); dep1++) {
setBodyParameter("JobIdList."+ std::to_string(dep1), std::to_string(jobIdList.at(dep1)));
}
std::vector<long> BatchDeleteJobsRequest::getJobIdList() const {
return jobIdList_;
}
std::string BatchDeleteJobsRequest::getRegionId()const
{
return regionId_;
void BatchDeleteJobsRequest::setJobIdList(const std::vector<long> &jobIdList) {
jobIdList_ = jobIdList;
}
void BatchDeleteJobsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string BatchDeleteJobsRequest::getRegionId() const {
return regionId_;
}
std::string BatchDeleteJobsRequest::get_Namespace()const
{
return _namespace_;
void BatchDeleteJobsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void BatchDeleteJobsRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string BatchDeleteJobsRequest::get_Namespace() const {
return _namespace_;
}
void BatchDeleteJobsRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

95
schedulerx2/src/model/BatchDisableJobsRequest.cc
View File

@@ -1,86 +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.
*/
#include <alibabacloud/schedulerx2/model/BatchDisableJobsRequest.h>
using AlibabaCloud::Schedulerx2::Model::BatchDisableJobsRequest;
BatchDisableJobsRequest::BatchDisableJobsRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "BatchDisableJobs")
{
setMethod(HttpRequest::Method::Post);
}
BatchDisableJobsRequest::~BatchDisableJobsRequest()
{}
std::string BatchDisableJobsRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/BatchDisableJobsRequest.h>
using AlibabaCloud::Schedulerx2::Model::BatchDisableJobsRequest;
BatchDisableJobsRequest::BatchDisableJobsRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "BatchDisableJobs") {
setMethod(HttpRequest::Method::Post);
}
void BatchDisableJobsRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
BatchDisableJobsRequest::~BatchDisableJobsRequest() {}
std::string BatchDisableJobsRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string BatchDisableJobsRequest::getRegionId()const
{
return regionId_;
void BatchDisableJobsRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void BatchDisableJobsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string BatchDisableJobsRequest::getRegionId() const {
return regionId_;
}
std::string BatchDisableJobsRequest::getGroupId()const
{
return groupId_;
void BatchDisableJobsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void BatchDisableJobsRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string BatchDisableJobsRequest::getGroupId() const {
return groupId_;
}
std::string BatchDisableJobsRequest::get_Namespace()const
{
return _namespace_;
void BatchDisableJobsRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void BatchDisableJobsRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string BatchDisableJobsRequest::get_Namespace() const {
return _namespace_;
}
std::vector<long> BatchDisableJobsRequest::getJobIdList()const
{
return jobIdList_;
void BatchDisableJobsRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void BatchDisableJobsRequest::setJobIdList(const std::vector<long>& jobIdList)
{
jobIdList_ = jobIdList;
for(int dep1 = 0; dep1!= jobIdList.size(); dep1++) {
setBodyParameter("JobIdList."+ std::to_string(dep1), std::to_string(jobIdList.at(dep1)));
}
std::vector<long> BatchDisableJobsRequest::getJobIdList() const {
return jobIdList_;
}
void BatchDisableJobsRequest::setJobIdList(const std::vector<long> &jobIdList) {
jobIdList_ = jobIdList;
}

4
schedulerx2/src/model/BatchDisableJobsResult.cc
View File

@@ -41,10 +41,10 @@ void BatchDisableJobsResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

95
schedulerx2/src/model/BatchEnableJobsRequest.cc
View File

@@ -1,86 +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.
*/
#include <alibabacloud/schedulerx2/model/BatchEnableJobsRequest.h>
using AlibabaCloud::Schedulerx2::Model::BatchEnableJobsRequest;
BatchEnableJobsRequest::BatchEnableJobsRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "BatchEnableJobs")
{
setMethod(HttpRequest::Method::Post);
}
BatchEnableJobsRequest::~BatchEnableJobsRequest()
{}
std::string BatchEnableJobsRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/BatchEnableJobsRequest.h>
using AlibabaCloud::Schedulerx2::Model::BatchEnableJobsRequest;
BatchEnableJobsRequest::BatchEnableJobsRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "BatchEnableJobs") {
setMethod(HttpRequest::Method::Post);
}
void BatchEnableJobsRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
BatchEnableJobsRequest::~BatchEnableJobsRequest() {}
std::string BatchEnableJobsRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string BatchEnableJobsRequest::getRegionId()const
{
return regionId_;
void BatchEnableJobsRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void BatchEnableJobsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string BatchEnableJobsRequest::getRegionId() const {
return regionId_;
}
std::string BatchEnableJobsRequest::getGroupId()const
{
return groupId_;
void BatchEnableJobsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void BatchEnableJobsRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string BatchEnableJobsRequest::getGroupId() const {
return groupId_;
}
std::string BatchEnableJobsRequest::get_Namespace()const
{
return _namespace_;
void BatchEnableJobsRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void BatchEnableJobsRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string BatchEnableJobsRequest::get_Namespace() const {
return _namespace_;
}
std::vector<long> BatchEnableJobsRequest::getJobIdList()const
{
return jobIdList_;
void BatchEnableJobsRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void BatchEnableJobsRequest::setJobIdList(const std::vector<long>& jobIdList)
{
jobIdList_ = jobIdList;
for(int dep1 = 0; dep1!= jobIdList.size(); dep1++) {
setBodyParameter("JobIdList."+ std::to_string(dep1), std::to_string(jobIdList.at(dep1)));
}
std::vector<long> BatchEnableJobsRequest::getJobIdList() const {
return jobIdList_;
}
void BatchEnableJobsRequest::setJobIdList(const std::vector<long> &jobIdList) {
jobIdList_ = jobIdList;
}

4
schedulerx2/src/model/BatchEnableJobsResult.cc
View File

@@ -41,10 +41,10 @@ void BatchEnableJobsResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

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

@@ -1,139 +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/CreateAppGroupRequest.h>
using AlibabaCloud::Schedulerx2::Model::CreateAppGroupRequest;
CreateAppGroupRequest::CreateAppGroupRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "CreateAppGroup")
{
setMethod(HttpRequest::Method::Get);
}
CreateAppGroupRequest::~CreateAppGroupRequest()
{}
int CreateAppGroupRequest::getMaxJobs()const
{
return maxJobs_;
*/
#include <alibabacloud/schedulerx2/model/CreateAppGroupRequest.h>
using AlibabaCloud::Schedulerx2::Model::CreateAppGroupRequest;
CreateAppGroupRequest::CreateAppGroupRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "CreateAppGroup") {
setMethod(HttpRequest::Method::Get);
}
void CreateAppGroupRequest::setMaxJobs(int maxJobs)
{
maxJobs_ = maxJobs;
setParameter("MaxJobs", std::to_string(maxJobs));
CreateAppGroupRequest::~CreateAppGroupRequest() {}
int CreateAppGroupRequest::getMaxJobs() const {
return maxJobs_;
}
std::string CreateAppGroupRequest::getNamespaceName()const
{
return namespaceName_;
void CreateAppGroupRequest::setMaxJobs(int maxJobs) {
maxJobs_ = maxJobs;
setParameter(std::string("MaxJobs"), std::to_string(maxJobs));
}
void CreateAppGroupRequest::setNamespaceName(const std::string& namespaceName)
{
namespaceName_ = namespaceName;
setParameter("NamespaceName", namespaceName);
std::string CreateAppGroupRequest::getNamespaceName() const {
return namespaceName_;
}
std::string CreateAppGroupRequest::getNamespaceSource()const
{
return namespaceSource_;
void CreateAppGroupRequest::setNamespaceName(const std::string &namespaceName) {
namespaceName_ = namespaceName;
setParameter(std::string("NamespaceName"), namespaceName);
}
void CreateAppGroupRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
std::string CreateAppGroupRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string CreateAppGroupRequest::getMetricsThresholdJson()const
{
return metricsThresholdJson_;
void CreateAppGroupRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void CreateAppGroupRequest::setMetricsThresholdJson(const std::string& metricsThresholdJson)
{
metricsThresholdJson_ = metricsThresholdJson;
setParameter("MetricsThresholdJson", metricsThresholdJson);
std::string CreateAppGroupRequest::getMetricsThresholdJson() const {
return metricsThresholdJson_;
}
std::string CreateAppGroupRequest::getGroupId()const
{
return groupId_;
void CreateAppGroupRequest::setMetricsThresholdJson(const std::string &metricsThresholdJson) {
metricsThresholdJson_ = metricsThresholdJson;
setParameter(std::string("MetricsThresholdJson"), metricsThresholdJson);
}
void CreateAppGroupRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string CreateAppGroupRequest::getGroupId() const {
return groupId_;
}
std::string CreateAppGroupRequest::getDescription()const
{
return description_;
void CreateAppGroupRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void CreateAppGroupRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
std::string CreateAppGroupRequest::getDescription() const {
return description_;
}
std::string CreateAppGroupRequest::getAppName()const
{
return appName_;
void CreateAppGroupRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
void CreateAppGroupRequest::setAppName(const std::string& appName)
{
appName_ = appName;
setParameter("AppName", appName);
std::string CreateAppGroupRequest::getAppName() const {
return appName_;
}
std::string CreateAppGroupRequest::getRegionId()const
{
return regionId_;
void CreateAppGroupRequest::setAppName(const std::string &appName) {
appName_ = appName;
setParameter(std::string("AppName"), appName);
}
void CreateAppGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string CreateAppGroupRequest::getRegionId() const {
return regionId_;
}
std::string CreateAppGroupRequest::get_Namespace()const
{
return _namespace_;
void CreateAppGroupRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void CreateAppGroupRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string CreateAppGroupRequest::get_Namespace() const {
return _namespace_;
}
std::string CreateAppGroupRequest::getAlarmJson()const
{
return alarmJson_;
void CreateAppGroupRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void CreateAppGroupRequest::setAlarmJson(const std::string& alarmJson)
{
alarmJson_ = alarmJson;
setParameter("AlarmJson", alarmJson);
std::string CreateAppGroupRequest::getAlarmJson() const {
return alarmJson_;
}
void CreateAppGroupRequest::setAlarmJson(const std::string &alarmJson) {
alarmJson_ = alarmJson;
setParameter(std::string("AlarmJson"), alarmJson);
}

4
schedulerx2/src/model/CreateAppGroupResult.cc
View File

@@ -44,10 +44,10 @@ void CreateAppGroupResult::parse(const std::string &payload)
data_.appGroupId = std::stol(dataNode["AppGroupId"].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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

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

@@ -1,375 +1,311 @@
/*
* 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/CreateJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::CreateJobRequest;
CreateJobRequest::CreateJobRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "CreateJob")
{
setMethod(HttpRequest::Method::Post);
}
CreateJobRequest::~CreateJobRequest()
{}
std::string CreateJobRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/CreateJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::CreateJobRequest;
CreateJobRequest::CreateJobRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "CreateJob") {
setMethod(HttpRequest::Method::Post);
}
void CreateJobRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setBodyParameter("NamespaceSource", namespaceSource);
CreateJobRequest::~CreateJobRequest() {}
std::string CreateJobRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string CreateJobRequest::getDescription()const
{
return description_;
void CreateJobRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setBodyParameter(std::string("NamespaceSource"), namespaceSource);
}
void CreateJobRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
std::string CreateJobRequest::getDescription() const {
return description_;
}
int CreateJobRequest::getAttemptInterval()const
{
return attemptInterval_;
void CreateJobRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
void CreateJobRequest::setAttemptInterval(int attemptInterval)
{
attemptInterval_ = attemptInterval;
setBodyParameter("AttemptInterval", std::to_string(attemptInterval));
int CreateJobRequest::getAttemptInterval() const {
return attemptInterval_;
}
std::string CreateJobRequest::getContent()const
{
return content_;
void CreateJobRequest::setAttemptInterval(int attemptInterval) {
attemptInterval_ = attemptInterval;
setBodyParameter(std::string("AttemptInterval"), std::to_string(attemptInterval));
}
void CreateJobRequest::setContent(const std::string& content)
{
content_ = content;
setBodyParameter("Content", content);
std::string CreateJobRequest::getContent() const {
return content_;
}
long CreateJobRequest::getTimeout()const
{
return timeout_;
void CreateJobRequest::setContent(const std::string &content) {
content_ = content;
setBodyParameter(std::string("Content"), content);
}
void CreateJobRequest::setTimeout(long timeout)
{
timeout_ = timeout;
setBodyParameter("Timeout", std::to_string(timeout));
long CreateJobRequest::getTimeout() const {
return timeout_;
}
bool CreateJobRequest::getTimeoutKillEnable()const
{
return timeoutKillEnable_;
void CreateJobRequest::setTimeout(long timeout) {
timeout_ = timeout;
setBodyParameter(std::string("Timeout"), std::to_string(timeout));
}
void CreateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable)
{
timeoutKillEnable_ = timeoutKillEnable;
setBodyParameter("TimeoutKillEnable", timeoutKillEnable ? "true" : "false");
bool CreateJobRequest::getTimeoutKillEnable() const {
return timeoutKillEnable_;
}
std::string CreateJobRequest::getRegionId()const
{
return regionId_;
void CreateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable) {
timeoutKillEnable_ = timeoutKillEnable;
setBodyParameter(std::string("TimeoutKillEnable"), timeoutKillEnable ? "true" : "false");
}
void CreateJobRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string CreateJobRequest::getRegionId() const {
return regionId_;
}
int CreateJobRequest::getPageSize()const
{
return pageSize_;
void CreateJobRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void CreateJobRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setBodyParameter("PageSize", std::to_string(pageSize));
int CreateJobRequest::getPageSize() const {
return pageSize_;
}
int CreateJobRequest::getConsumerSize()const
{
return consumerSize_;
void CreateJobRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
}
void CreateJobRequest::setConsumerSize(int consumerSize)
{
consumerSize_ = consumerSize;
setBodyParameter("ConsumerSize", std::to_string(consumerSize));
int CreateJobRequest::getConsumerSize() const {
return consumerSize_;
}
std::string CreateJobRequest::getJarUrl()const
{
return jarUrl_;
void CreateJobRequest::setConsumerSize(int consumerSize) {
consumerSize_ = consumerSize;
setBodyParameter(std::string("ConsumerSize"), std::to_string(consumerSize));
}
void CreateJobRequest::setJarUrl(const std::string& jarUrl)
{
jarUrl_ = jarUrl;
setBodyParameter("JarUrl", jarUrl);
std::string CreateJobRequest::getJarUrl() const {
return jarUrl_;
}
std::string CreateJobRequest::getCalendar()const
{
return calendar_;
void CreateJobRequest::setJarUrl(const std::string &jarUrl) {
jarUrl_ = jarUrl;
setBodyParameter(std::string("JarUrl"), jarUrl);
}
void CreateJobRequest::setCalendar(const std::string& calendar)
{
calendar_ = calendar;
setBodyParameter("Calendar", calendar);
std::string CreateJobRequest::getCalendar() const {
return calendar_;
}
bool CreateJobRequest::getFailEnable()const
{
return failEnable_;
void CreateJobRequest::setCalendar(const std::string &calendar) {
calendar_ = calendar;
setBodyParameter(std::string("Calendar"), calendar);
}
void CreateJobRequest::setFailEnable(bool failEnable)
{
failEnable_ = failEnable;
setBodyParameter("FailEnable", failEnable ? "true" : "false");
bool CreateJobRequest::getFailEnable() const {
return failEnable_;
}
std::string CreateJobRequest::getSendChannel()const
{
return sendChannel_;
void CreateJobRequest::setFailEnable(bool failEnable) {
failEnable_ = failEnable;
setBodyParameter(std::string("FailEnable"), failEnable ? "true" : "false");
}
void CreateJobRequest::setSendChannel(const std::string& sendChannel)
{
sendChannel_ = sendChannel;
setBodyParameter("SendChannel", sendChannel);
std::string CreateJobRequest::getSendChannel() const {
return sendChannel_;
}
int CreateJobRequest::getDataOffset()const
{
return dataOffset_;
void CreateJobRequest::setSendChannel(const std::string &sendChannel) {
sendChannel_ = sendChannel;
setBodyParameter(std::string("SendChannel"), sendChannel);
}
void CreateJobRequest::setDataOffset(int dataOffset)
{
dataOffset_ = dataOffset;
setBodyParameter("DataOffset", std::to_string(dataOffset));
int CreateJobRequest::getDataOffset() const {
return dataOffset_;
}
std::string CreateJobRequest::getGroupId()const
{
return groupId_;
void CreateJobRequest::setDataOffset(int dataOffset) {
dataOffset_ = dataOffset;
setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset));
}
void CreateJobRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setBodyParameter("GroupId", groupId);
std::string CreateJobRequest::getGroupId() const {
return groupId_;
}
int CreateJobRequest::getTaskMaxAttempt()const
{
return taskMaxAttempt_;
void CreateJobRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setBodyParameter(std::string("GroupId"), groupId);
}
void CreateJobRequest::setTaskMaxAttempt(int taskMaxAttempt)
{
taskMaxAttempt_ = taskMaxAttempt;
setBodyParameter("TaskMaxAttempt", std::to_string(taskMaxAttempt));
int CreateJobRequest::getTaskMaxAttempt() const {
return taskMaxAttempt_;
}
int CreateJobRequest::getMaxAttempt()const
{
return maxAttempt_;
void CreateJobRequest::setTaskMaxAttempt(int taskMaxAttempt) {
taskMaxAttempt_ = taskMaxAttempt;
setBodyParameter(std::string("TaskMaxAttempt"), std::to_string(taskMaxAttempt));
}
void CreateJobRequest::setMaxAttempt(int maxAttempt)
{
maxAttempt_ = maxAttempt;
setBodyParameter("MaxAttempt", std::to_string(maxAttempt));
int CreateJobRequest::getMaxAttempt() const {
return maxAttempt_;
}
int CreateJobRequest::getDispatcherSize()const
{
return dispatcherSize_;
void CreateJobRequest::setMaxAttempt(int maxAttempt) {
maxAttempt_ = maxAttempt;
setBodyParameter(std::string("MaxAttempt"), std::to_string(maxAttempt));
}
void CreateJobRequest::setDispatcherSize(int dispatcherSize)
{
dispatcherSize_ = dispatcherSize;
setBodyParameter("DispatcherSize", std::to_string(dispatcherSize));
int CreateJobRequest::getDispatcherSize() const {
return dispatcherSize_;
}
std::string CreateJobRequest::getJobType()const
{
return jobType_;
void CreateJobRequest::setDispatcherSize(int dispatcherSize) {
dispatcherSize_ = dispatcherSize;
setBodyParameter(std::string("DispatcherSize"), std::to_string(dispatcherSize));
}
void CreateJobRequest::setJobType(const std::string& jobType)
{
jobType_ = jobType;
setBodyParameter("JobType", jobType);
std::string CreateJobRequest::getJobType() const {
return jobType_;
}
int CreateJobRequest::getTaskAttemptInterval()const
{
return taskAttemptInterval_;
void CreateJobRequest::setJobType(const std::string &jobType) {
jobType_ = jobType;
setBodyParameter(std::string("JobType"), jobType);
}
void CreateJobRequest::setTaskAttemptInterval(int taskAttemptInterval)
{
taskAttemptInterval_ = taskAttemptInterval;
setBodyParameter("TaskAttemptInterval", std::to_string(taskAttemptInterval));
int CreateJobRequest::getTaskAttemptInterval() const {
return taskAttemptInterval_;
}
std::string CreateJobRequest::getExecuteMode()const
{
return executeMode_;
void CreateJobRequest::setTaskAttemptInterval(int taskAttemptInterval) {
taskAttemptInterval_ = taskAttemptInterval;
setBodyParameter(std::string("TaskAttemptInterval"), std::to_string(taskAttemptInterval));
}
void CreateJobRequest::setExecuteMode(const std::string& executeMode)
{
executeMode_ = executeMode;
setBodyParameter("ExecuteMode", executeMode);
std::string CreateJobRequest::getExecuteMode() const {
return executeMode_;
}
int CreateJobRequest::getQueueSize()const
{
return queueSize_;
void CreateJobRequest::setExecuteMode(const std::string &executeMode) {
executeMode_ = executeMode;
setBodyParameter(std::string("ExecuteMode"), executeMode);
}
void CreateJobRequest::setQueueSize(int queueSize)
{
queueSize_ = queueSize;
setBodyParameter("QueueSize", std::to_string(queueSize));
int CreateJobRequest::getQueueSize() const {
return queueSize_;
}
std::string CreateJobRequest::getTimeExpression()const
{
return timeExpression_;
void CreateJobRequest::setQueueSize(int queueSize) {
queueSize_ = queueSize;
setBodyParameter(std::string("QueueSize"), std::to_string(queueSize));
}
void CreateJobRequest::setTimeExpression(const std::string& timeExpression)
{
timeExpression_ = timeExpression;
setBodyParameter("TimeExpression", timeExpression);
std::string CreateJobRequest::getTimeExpression() const {
return timeExpression_;
}
std::string CreateJobRequest::getClassName()const
{
return className_;
void CreateJobRequest::setTimeExpression(const std::string &timeExpression) {
timeExpression_ = timeExpression;
setBodyParameter(std::string("TimeExpression"), timeExpression);
}
void CreateJobRequest::setClassName(const std::string& className)
{
className_ = className;
setBodyParameter("ClassName", className);
std::string CreateJobRequest::getClassName() const {
return className_;
}
bool CreateJobRequest::getTimeoutEnable()const
{
return timeoutEnable_;
void CreateJobRequest::setClassName(const std::string &className) {
className_ = className;
setBodyParameter(std::string("ClassName"), className);
}
void CreateJobRequest::setTimeoutEnable(bool timeoutEnable)
{
timeoutEnable_ = timeoutEnable;
setBodyParameter("TimeoutEnable", timeoutEnable ? "true" : "false");
bool CreateJobRequest::getTimeoutEnable() const {
return timeoutEnable_;
}
std::vector<CreateJobRequest::ContactInfo> CreateJobRequest::getContactInfo()const
{
return contactInfo_;
void CreateJobRequest::setTimeoutEnable(bool timeoutEnable) {
timeoutEnable_ = timeoutEnable;
setBodyParameter(std::string("TimeoutEnable"), timeoutEnable ? "true" : "false");
}
void CreateJobRequest::setContactInfo(const std::vector<ContactInfo>& contactInfo)
{
contactInfo_ = contactInfo;
for(int dep1 = 0; dep1!= contactInfo.size(); dep1++) {
auto contactInfoObj = contactInfo.at(dep1);
std::string contactInfoObjStr = "ContactInfo." + std::to_string(dep1 + 1);
setParameter(contactInfoObjStr + ".UserPhone", contactInfoObj.userPhone);
setParameter(contactInfoObjStr + ".UserName", contactInfoObj.userName);
}
std::vector<CreateJobRequest::ContactInfo> CreateJobRequest::getContactInfo() const {
return contactInfo_;
}
std::string CreateJobRequest::getName()const
{
return name_;
void CreateJobRequest::setContactInfo(const std::vector<CreateJobRequest::ContactInfo> &contactInfo) {
contactInfo_ = contactInfo;
for(int dep1 = 0; dep1 != contactInfo.size(); dep1++) {
auto contactInfoObj = contactInfo.at(dep1);
std::string contactInfoObjStr = std::string("ContactInfo") + "." + std::to_string(dep1 + 1);
setBodyParameter(contactInfoObjStr + ".UserPhone", contactInfoObj.userPhone);
setBodyParameter(contactInfoObjStr + ".UserName", contactInfoObj.userName);
}
}
void CreateJobRequest::setName(const std::string& name)
{
name_ = name;
setBodyParameter("Name", name);
std::string CreateJobRequest::getName() const {
return name_;
}
std::string CreateJobRequest::get_Namespace()const
{
return _namespace_;
void CreateJobRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
void CreateJobRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setBodyParameter("_Namespace", _namespace);
std::string CreateJobRequest::get_Namespace() const {
return _namespace_;
}
int CreateJobRequest::getMaxConcurrency()const
{
return maxConcurrency_;
void CreateJobRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setBodyParameter(std::string("Namespace"), _namespace);
}
void CreateJobRequest::setMaxConcurrency(int maxConcurrency)
{
maxConcurrency_ = maxConcurrency;
setBodyParameter("MaxConcurrency", std::to_string(maxConcurrency));
int CreateJobRequest::getMaxConcurrency() const {
return maxConcurrency_;
}
int CreateJobRequest::getTimeType()const
{
return timeType_;
void CreateJobRequest::setMaxConcurrency(int maxConcurrency) {
maxConcurrency_ = maxConcurrency;
setBodyParameter(std::string("MaxConcurrency"), std::to_string(maxConcurrency));
}
void CreateJobRequest::setTimeType(int timeType)
{
timeType_ = timeType;
setBodyParameter("TimeType", std::to_string(timeType));
int CreateJobRequest::getTimeType() const {
return timeType_;
}
std::string CreateJobRequest::getParameters()const
{
return parameters_;
void CreateJobRequest::setTimeType(int timeType) {
timeType_ = timeType;
setBodyParameter(std::string("TimeType"), std::to_string(timeType));
}
void CreateJobRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setBodyParameter("Parameters", parameters);
std::string CreateJobRequest::getParameters() const {
return parameters_;
}
void CreateJobRequest::setParameters(const std::string &parameters) {
parameters_ = parameters;
setBodyParameter(std::string("Parameters"), parameters);
}

4
schedulerx2/src/model/CreateJobResult.cc
View File

@@ -44,10 +44,10 @@ void CreateJobResult::parse(const std::string &payload)
data_.jobId = std::stol(dataNode["JobId"].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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

94
schedulerx2/src/model/DeleteJobRequest.cc
View File

@@ -1,84 +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/DeleteJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::DeleteJobRequest;
DeleteJobRequest::DeleteJobRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "DeleteJob")
{
setMethod(HttpRequest::Method::Get);
}
DeleteJobRequest::~DeleteJobRequest()
{}
std::string DeleteJobRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/DeleteJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::DeleteJobRequest;
DeleteJobRequest::DeleteJobRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "DeleteJob") {
setMethod(HttpRequest::Method::Get);
}
void DeleteJobRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
DeleteJobRequest::~DeleteJobRequest() {}
std::string DeleteJobRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string DeleteJobRequest::getGroupId()const
{
return groupId_;
void DeleteJobRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void DeleteJobRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string DeleteJobRequest::getGroupId() const {
return groupId_;
}
long DeleteJobRequest::getJobId()const
{
return jobId_;
void DeleteJobRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void DeleteJobRequest::setJobId(long jobId)
{
jobId_ = jobId;
setParameter("JobId", std::to_string(jobId));
long DeleteJobRequest::getJobId() const {
return jobId_;
}
std::string DeleteJobRequest::getRegionId()const
{
return regionId_;
void DeleteJobRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
void DeleteJobRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DeleteJobRequest::getRegionId() const {
return regionId_;
}
std::string DeleteJobRequest::get_Namespace()const
{
return _namespace_;
void DeleteJobRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DeleteJobRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string DeleteJobRequest::get_Namespace() const {
return _namespace_;
}
void DeleteJobRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

94
schedulerx2/src/model/DeleteWorkflowRequest.cc
View File

@@ -1,84 +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/DeleteWorkflowRequest.h>
using AlibabaCloud::Schedulerx2::Model::DeleteWorkflowRequest;
DeleteWorkflowRequest::DeleteWorkflowRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "DeleteWorkflow")
{
setMethod(HttpRequest::Method::Get);
}
DeleteWorkflowRequest::~DeleteWorkflowRequest()
{}
std::string DeleteWorkflowRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/DeleteWorkflowRequest.h>
using AlibabaCloud::Schedulerx2::Model::DeleteWorkflowRequest;
DeleteWorkflowRequest::DeleteWorkflowRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "DeleteWorkflow") {
setMethod(HttpRequest::Method::Get);
}
void DeleteWorkflowRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
DeleteWorkflowRequest::~DeleteWorkflowRequest() {}
std::string DeleteWorkflowRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string DeleteWorkflowRequest::getRegionId()const
{
return regionId_;
void DeleteWorkflowRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void DeleteWorkflowRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DeleteWorkflowRequest::getRegionId() const {
return regionId_;
}
std::string DeleteWorkflowRequest::getGroupId()const
{
return groupId_;
void DeleteWorkflowRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DeleteWorkflowRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string DeleteWorkflowRequest::getGroupId() const {
return groupId_;
}
std::string DeleteWorkflowRequest::get_Namespace()const
{
return _namespace_;
void DeleteWorkflowRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void DeleteWorkflowRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string DeleteWorkflowRequest::get_Namespace() const {
return _namespace_;
}
long DeleteWorkflowRequest::getWorkflowId()const
{
return workflowId_;
void DeleteWorkflowRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void DeleteWorkflowRequest::setWorkflowId(long workflowId)
{
workflowId_ = workflowId;
setParameter("WorkflowId", std::to_string(workflowId));
long DeleteWorkflowRequest::getWorkflowId() const {
return workflowId_;
}
void DeleteWorkflowRequest::setWorkflowId(long workflowId) {
workflowId_ = workflowId;
setParameter(std::string("WorkflowId"), std::to_string(workflowId));
}

4
schedulerx2/src/model/DeleteWorkflowResult.cc
View File

@@ -41,10 +41,10 @@ void DeleteWorkflowResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

34
schedulerx2/src/model/DescribeRegionsRequest.cc
View File

@@ -1,29 +1,27 @@
/*
* 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/DescribeRegionsRequest.h>
using AlibabaCloud::Schedulerx2::Model::DescribeRegionsRequest;
DescribeRegionsRequest::DescribeRegionsRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "DescribeRegions")
{
setMethod(HttpRequest::Method::Post);
}
DescribeRegionsRequest::~DescribeRegionsRequest()
{}
*/
#include <alibabacloud/schedulerx2/model/DescribeRegionsRequest.h>
using AlibabaCloud::Schedulerx2::Model::DescribeRegionsRequest;
DescribeRegionsRequest::DescribeRegionsRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "DescribeRegions") {
setMethod(HttpRequest::Method::Post);
}
DescribeRegionsRequest::~DescribeRegionsRequest() {}

8
schedulerx2/src/model/DescribeRegionsResult.cc
View File

@@ -43,12 +43,12 @@ void DescribeRegionsResult::parse(const std::string &payload)
for (auto valueRegionsRegion : allRegionsNode)
{
Region regionsObject;
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
if(!valueRegionsRegion["LocalName"].isNull())
regionsObject.localName = valueRegionsRegion["LocalName"].asString();
if(!valueRegionsRegion["RegionEndpoint"].isNull())
regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
if(!valueRegionsRegion["LocalName"].isNull())
regionsObject.localName = valueRegionsRegion["LocalName"].asString();
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
regions_.push_back(regionsObject);
}
if(!value["Code"].isNull())

108
schedulerx2/src/model/DesignateWorkersRequest.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/DesignateWorkersRequest.h>
using AlibabaCloud::Schedulerx2::Model::DesignateWorkersRequest;
DesignateWorkersRequest::DesignateWorkersRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "DesignateWorkers") {
setMethod(HttpRequest::Method::Get);
}
DesignateWorkersRequest::~DesignateWorkersRequest() {}
std::string DesignateWorkersRequest::getNamespaceSource() const {
return namespaceSource_;
}
void DesignateWorkersRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
std::string DesignateWorkersRequest::getGroupId() const {
return groupId_;
}
void DesignateWorkersRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
bool DesignateWorkersRequest::getTransferable() const {
return transferable_;
}
void DesignateWorkersRequest::setTransferable(bool transferable) {
transferable_ = transferable;
setParameter(std::string("Transferable"), transferable ? "true" : "false");
}
std::string DesignateWorkersRequest::getLabels() const {
return labels_;
}
void DesignateWorkersRequest::setLabels(const std::string &labels) {
labels_ = labels;
setParameter(std::string("Labels"), labels);
}
int DesignateWorkersRequest::getDesignateType() const {
return designateType_;
}
void DesignateWorkersRequest::setDesignateType(int designateType) {
designateType_ = designateType;
setParameter(std::string("DesignateType"), std::to_string(designateType));
}
long DesignateWorkersRequest::getJobId() const {
return jobId_;
}
void DesignateWorkersRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
std::string DesignateWorkersRequest::getRegionId() const {
return regionId_;
}
void DesignateWorkersRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string DesignateWorkersRequest::get_Namespace() const {
return _namespace_;
}
void DesignateWorkersRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
std::string DesignateWorkersRequest::getWorkers() const {
return workers_;
}
void DesignateWorkersRequest::setWorkers(const std::string &workers) {
workers_ = workers;
setParameter(std::string("Workers"), workers);
}

65
schedulerx2/src/model/DesignateWorkersResult.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/DesignateWorkersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Schedulerx2;
using namespace AlibabaCloud::Schedulerx2::Model;
DesignateWorkersResult::DesignateWorkersResult() :
ServiceResult()
{}
DesignateWorkersResult::DesignateWorkersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DesignateWorkersResult::~DesignateWorkersResult()
{}
void DesignateWorkersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string DesignateWorkersResult::getMessage()const
{
return message_;
}
int DesignateWorkersResult::getCode()const
{
return code_;
}
bool DesignateWorkersResult::getSuccess()const
{
return success_;
}

94
schedulerx2/src/model/DisableJobRequest.cc
View File

@@ -1,84 +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/DisableJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::DisableJobRequest;
DisableJobRequest::DisableJobRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "DisableJob")
{
setMethod(HttpRequest::Method::Get);
}
DisableJobRequest::~DisableJobRequest()
{}
long DisableJobRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/schedulerx2/model/DisableJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::DisableJobRequest;
DisableJobRequest::DisableJobRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "DisableJob") {
setMethod(HttpRequest::Method::Get);
}
void DisableJobRequest::setJobId(long jobId)
{
jobId_ = jobId;
setParameter("JobId", std::to_string(jobId));
DisableJobRequest::~DisableJobRequest() {}
long DisableJobRequest::getJobId() const {
return jobId_;
}
std::string DisableJobRequest::getNamespaceSource()const
{
return namespaceSource_;
void DisableJobRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
void DisableJobRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
std::string DisableJobRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string DisableJobRequest::getRegionId()const
{
return regionId_;
void DisableJobRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void DisableJobRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DisableJobRequest::getRegionId() const {
return regionId_;
}
std::string DisableJobRequest::getGroupId()const
{
return groupId_;
void DisableJobRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DisableJobRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string DisableJobRequest::getGroupId() const {
return groupId_;
}
std::string DisableJobRequest::get_Namespace()const
{
return _namespace_;
void DisableJobRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void DisableJobRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string DisableJobRequest::get_Namespace() const {
return _namespace_;
}
void DisableJobRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

4
schedulerx2/src/model/DisableJobResult.cc
View File

@@ -41,10 +41,10 @@ void DisableJobResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

94
schedulerx2/src/model/DisableWorkflowRequest.cc
View File

@@ -1,84 +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/DisableWorkflowRequest.h>
using AlibabaCloud::Schedulerx2::Model::DisableWorkflowRequest;
DisableWorkflowRequest::DisableWorkflowRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "DisableWorkflow")
{
setMethod(HttpRequest::Method::Get);
}
DisableWorkflowRequest::~DisableWorkflowRequest()
{}
std::string DisableWorkflowRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/DisableWorkflowRequest.h>
using AlibabaCloud::Schedulerx2::Model::DisableWorkflowRequest;
DisableWorkflowRequest::DisableWorkflowRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "DisableWorkflow") {
setMethod(HttpRequest::Method::Get);
}
void DisableWorkflowRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
DisableWorkflowRequest::~DisableWorkflowRequest() {}
std::string DisableWorkflowRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string DisableWorkflowRequest::getRegionId()const
{
return regionId_;
void DisableWorkflowRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void DisableWorkflowRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DisableWorkflowRequest::getRegionId() const {
return regionId_;
}
std::string DisableWorkflowRequest::getGroupId()const
{
return groupId_;
void DisableWorkflowRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DisableWorkflowRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string DisableWorkflowRequest::getGroupId() const {
return groupId_;
}
std::string DisableWorkflowRequest::get_Namespace()const
{
return _namespace_;
void DisableWorkflowRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void DisableWorkflowRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string DisableWorkflowRequest::get_Namespace() const {
return _namespace_;
}
long DisableWorkflowRequest::getWorkflowId()const
{
return workflowId_;
void DisableWorkflowRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void DisableWorkflowRequest::setWorkflowId(long workflowId)
{
workflowId_ = workflowId;
setParameter("WorkflowId", std::to_string(workflowId));
long DisableWorkflowRequest::getWorkflowId() const {
return workflowId_;
}
void DisableWorkflowRequest::setWorkflowId(long workflowId) {
workflowId_ = workflowId;
setParameter(std::string("WorkflowId"), std::to_string(workflowId));
}

4
schedulerx2/src/model/DisableWorkflowResult.cc
View File

@@ -41,10 +41,10 @@ void DisableWorkflowResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

94
schedulerx2/src/model/EnableJobRequest.cc
View File

@@ -1,84 +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/EnableJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::EnableJobRequest;
EnableJobRequest::EnableJobRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "EnableJob")
{
setMethod(HttpRequest::Method::Get);
}
EnableJobRequest::~EnableJobRequest()
{}
long EnableJobRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/schedulerx2/model/EnableJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::EnableJobRequest;
EnableJobRequest::EnableJobRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "EnableJob") {
setMethod(HttpRequest::Method::Get);
}
void EnableJobRequest::setJobId(long jobId)
{
jobId_ = jobId;
setParameter("JobId", std::to_string(jobId));
EnableJobRequest::~EnableJobRequest() {}
long EnableJobRequest::getJobId() const {
return jobId_;
}
std::string EnableJobRequest::getNamespaceSource()const
{
return namespaceSource_;
void EnableJobRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
void EnableJobRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
std::string EnableJobRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string EnableJobRequest::getRegionId()const
{
return regionId_;
void EnableJobRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void EnableJobRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string EnableJobRequest::getRegionId() const {
return regionId_;
}
std::string EnableJobRequest::getGroupId()const
{
return groupId_;
void EnableJobRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void EnableJobRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string EnableJobRequest::getGroupId() const {
return groupId_;
}
std::string EnableJobRequest::get_Namespace()const
{
return _namespace_;
void EnableJobRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void EnableJobRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string EnableJobRequest::get_Namespace() const {
return _namespace_;
}
void EnableJobRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

4
schedulerx2/src/model/EnableJobResult.cc
View File

@@ -41,10 +41,10 @@ void EnableJobResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

94
schedulerx2/src/model/EnableWorkflowRequest.cc
View File

@@ -1,84 +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/EnableWorkflowRequest.h>
using AlibabaCloud::Schedulerx2::Model::EnableWorkflowRequest;
EnableWorkflowRequest::EnableWorkflowRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "EnableWorkflow")
{
setMethod(HttpRequest::Method::Get);
}
EnableWorkflowRequest::~EnableWorkflowRequest()
{}
std::string EnableWorkflowRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/EnableWorkflowRequest.h>
using AlibabaCloud::Schedulerx2::Model::EnableWorkflowRequest;
EnableWorkflowRequest::EnableWorkflowRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "EnableWorkflow") {
setMethod(HttpRequest::Method::Get);
}
void EnableWorkflowRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
EnableWorkflowRequest::~EnableWorkflowRequest() {}
std::string EnableWorkflowRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string EnableWorkflowRequest::getRegionId()const
{
return regionId_;
void EnableWorkflowRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void EnableWorkflowRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string EnableWorkflowRequest::getRegionId() const {
return regionId_;
}
std::string EnableWorkflowRequest::getGroupId()const
{
return groupId_;
void EnableWorkflowRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void EnableWorkflowRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string EnableWorkflowRequest::getGroupId() const {
return groupId_;
}
std::string EnableWorkflowRequest::get_Namespace()const
{
return _namespace_;
void EnableWorkflowRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void EnableWorkflowRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string EnableWorkflowRequest::get_Namespace() const {
return _namespace_;
}
long EnableWorkflowRequest::getWorkflowId()const
{
return workflowId_;
void EnableWorkflowRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void EnableWorkflowRequest::setWorkflowId(long workflowId)
{
workflowId_ = workflowId;
setParameter("WorkflowId", std::to_string(workflowId));
long EnableWorkflowRequest::getWorkflowId() const {
return workflowId_;
}
void EnableWorkflowRequest::setWorkflowId(long workflowId) {
workflowId_ = workflowId;
setParameter(std::string("WorkflowId"), std::to_string(workflowId));
}

4
schedulerx2/src/model/EnableWorkflowResult.cc
View File

@@ -41,10 +41,10 @@ void EnableWorkflowResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

115
schedulerx2/src/model/ExecuteJobRequest.cc
View File

@@ -1,95 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/schedulerx2/model/ExecuteJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::ExecuteJobRequest;
ExecuteJobRequest::ExecuteJobRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "ExecuteJob")
{
setMethod(HttpRequest::Method::Get);
}
ExecuteJobRequest::~ExecuteJobRequest()
{}
long ExecuteJobRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/schedulerx2/model/ExecuteJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::ExecuteJobRequest;
ExecuteJobRequest::ExecuteJobRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "ExecuteJob") {
setMethod(HttpRequest::Method::Get);
}
void ExecuteJobRequest::setJobId(long jobId)
{
jobId_ = jobId;
setParameter("JobId", std::to_string(jobId));
ExecuteJobRequest::~ExecuteJobRequest() {}
std::string ExecuteJobRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string ExecuteJobRequest::getNamespaceSource()const
{
return namespaceSource_;
void ExecuteJobRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void ExecuteJobRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
bool ExecuteJobRequest::getCheckJobStatus() const {
return checkJobStatus_;
}
std::string ExecuteJobRequest::getRegionId()const
{
return regionId_;
void ExecuteJobRequest::setCheckJobStatus(bool checkJobStatus) {
checkJobStatus_ = checkJobStatus;
setParameter(std::string("CheckJobStatus"), checkJobStatus ? "true" : "false");
}
void ExecuteJobRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ExecuteJobRequest::getGroupId() const {
return groupId_;
}
std::string ExecuteJobRequest::getGroupId()const
{
return groupId_;
void ExecuteJobRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void ExecuteJobRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
long ExecuteJobRequest::getJobId() const {
return jobId_;
}
std::string ExecuteJobRequest::get_Namespace()const
{
return _namespace_;
void ExecuteJobRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
void ExecuteJobRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string ExecuteJobRequest::getRegionId() const {
return regionId_;
}
std::string ExecuteJobRequest::getInstanceParameters()const
{
return instanceParameters_;
void ExecuteJobRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ExecuteJobRequest::setInstanceParameters(const std::string& instanceParameters)
{
instanceParameters_ = instanceParameters;
setParameter("InstanceParameters", instanceParameters);
std::string ExecuteJobRequest::get_Namespace() const {
return _namespace_;
}
void ExecuteJobRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
std::string ExecuteJobRequest::getInstanceParameters() const {
return instanceParameters_;
}
void ExecuteJobRequest::setInstanceParameters(const std::string &instanceParameters) {
instanceParameters_ = instanceParameters;
setParameter(std::string("InstanceParameters"), instanceParameters);
}

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

@@ -1,84 +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/ExecuteWorkflowRequest.h>
using AlibabaCloud::Schedulerx2::Model::ExecuteWorkflowRequest;
ExecuteWorkflowRequest::ExecuteWorkflowRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "ExecuteWorkflow")
{
setMethod(HttpRequest::Method::Get);
}
ExecuteWorkflowRequest::~ExecuteWorkflowRequest()
{}
std::string ExecuteWorkflowRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h>
using AlibabaCloud::Schedulerx2::Model::ExecuteWorkflowRequest;
ExecuteWorkflowRequest::ExecuteWorkflowRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "ExecuteWorkflow") {
setMethod(HttpRequest::Method::Get);
}
void ExecuteWorkflowRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
ExecuteWorkflowRequest::~ExecuteWorkflowRequest() {}
std::string ExecuteWorkflowRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string ExecuteWorkflowRequest::getGroupId()const
{
return groupId_;
void ExecuteWorkflowRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void ExecuteWorkflowRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string ExecuteWorkflowRequest::getGroupId() const {
return groupId_;
}
std::string ExecuteWorkflowRequest::get_Namespace()const
{
return _namespace_;
void ExecuteWorkflowRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void ExecuteWorkflowRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string ExecuteWorkflowRequest::get_Namespace() const {
return _namespace_;
}
long ExecuteWorkflowRequest::getWorkflowId()const
{
return workflowId_;
void ExecuteWorkflowRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void ExecuteWorkflowRequest::setWorkflowId(long workflowId)
{
workflowId_ = workflowId;
setParameter("WorkflowId", std::to_string(workflowId));
long ExecuteWorkflowRequest::getWorkflowId() const {
return workflowId_;
}
std::string ExecuteWorkflowRequest::getInstanceParameters()const
{
return instanceParameters_;
void ExecuteWorkflowRequest::setWorkflowId(long workflowId) {
workflowId_ = workflowId;
setParameter(std::string("WorkflowId"), std::to_string(workflowId));
}
void ExecuteWorkflowRequest::setInstanceParameters(const std::string& instanceParameters)
{
instanceParameters_ = instanceParameters;
setParameter("InstanceParameters", instanceParameters);
std::string ExecuteWorkflowRequest::getInstanceParameters() const {
return instanceParameters_;
}
void ExecuteWorkflowRequest::setInstanceParameters(const std::string &instanceParameters) {
instanceParameters_ = instanceParameters;
setParameter(std::string("InstanceParameters"), instanceParameters);
}

94
schedulerx2/src/model/GetJobInfoRequest.cc
View File

@@ -1,84 +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/GetJobInfoRequest.h>
using AlibabaCloud::Schedulerx2::Model::GetJobInfoRequest;
GetJobInfoRequest::GetJobInfoRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInfo")
{
setMethod(HttpRequest::Method::Get);
}
GetJobInfoRequest::~GetJobInfoRequest()
{}
long GetJobInfoRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/schedulerx2/model/GetJobInfoRequest.h>
using AlibabaCloud::Schedulerx2::Model::GetJobInfoRequest;
GetJobInfoRequest::GetJobInfoRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInfo") {
setMethod(HttpRequest::Method::Get);
}
void GetJobInfoRequest::setJobId(long jobId)
{
jobId_ = jobId;
setParameter("JobId", std::to_string(jobId));
GetJobInfoRequest::~GetJobInfoRequest() {}
long GetJobInfoRequest::getJobId() const {
return jobId_;
}
std::string GetJobInfoRequest::getNamespaceSource()const
{
return namespaceSource_;
void GetJobInfoRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
void GetJobInfoRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
std::string GetJobInfoRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string GetJobInfoRequest::getRegionId()const
{
return regionId_;
void GetJobInfoRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void GetJobInfoRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string GetJobInfoRequest::getRegionId() const {
return regionId_;
}
std::string GetJobInfoRequest::getGroupId()const
{
return groupId_;
void GetJobInfoRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void GetJobInfoRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string GetJobInfoRequest::getGroupId() const {
return groupId_;
}
std::string GetJobInfoRequest::get_Namespace()const
{
return _namespace_;
void GetJobInfoRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void GetJobInfoRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string GetJobInfoRequest::get_Namespace() const {
return _namespace_;
}
void GetJobInfoRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

60
schedulerx2/src/model/GetJobInfoResult.cc
View File

@@ -41,72 +41,72 @@ void GetJobInfoResult::parse(const std::string &payload)
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto jobConfigInfoNode = dataNode["JobConfigInfo"];
if(!jobConfigInfoNode["ClassName"].isNull())
data_.jobConfigInfo.className = jobConfigInfoNode["ClassName"].asString();
if(!jobConfigInfoNode["JarUrl"].isNull())
data_.jobConfigInfo.jarUrl = jobConfigInfoNode["JarUrl"].asString();
if(!jobConfigInfoNode["Content"].isNull())
data_.jobConfigInfo.content = jobConfigInfoNode["Content"].asString();
if(!jobConfigInfoNode["Name"].isNull())
data_.jobConfigInfo.name = jobConfigInfoNode["Name"].asString();
if(!jobConfigInfoNode["Description"].isNull())
data_.jobConfigInfo.description = jobConfigInfoNode["Description"].asString();
if(!jobConfigInfoNode["Status"].isNull())
data_.jobConfigInfo.status = std::stoi(jobConfigInfoNode["Status"].asString());
if(!jobConfigInfoNode["ExecuteMode"].isNull())
data_.jobConfigInfo.executeMode = jobConfigInfoNode["ExecuteMode"].asString();
if(!jobConfigInfoNode["Parameters"].isNull())
data_.jobConfigInfo.parameters = jobConfigInfoNode["Parameters"].asString();
if(!jobConfigInfoNode["Description"].isNull())
data_.jobConfigInfo.description = jobConfigInfoNode["Description"].asString();
if(!jobConfigInfoNode["ExecuteMode"].isNull())
data_.jobConfigInfo.executeMode = jobConfigInfoNode["ExecuteMode"].asString();
if(!jobConfigInfoNode["MaxConcurrency"].isNull())
data_.jobConfigInfo.maxConcurrency = jobConfigInfoNode["MaxConcurrency"].asString();
if(!jobConfigInfoNode["Name"].isNull())
data_.jobConfigInfo.name = jobConfigInfoNode["Name"].asString();
if(!jobConfigInfoNode["MaxAttempt"].isNull())
data_.jobConfigInfo.maxAttempt = std::stoi(jobConfigInfoNode["MaxAttempt"].asString());
if(!jobConfigInfoNode["Content"].isNull())
data_.jobConfigInfo.content = jobConfigInfoNode["Content"].asString();
if(!jobConfigInfoNode["JarUrl"].isNull())
data_.jobConfigInfo.jarUrl = jobConfigInfoNode["JarUrl"].asString();
if(!jobConfigInfoNode["ClassName"].isNull())
data_.jobConfigInfo.className = jobConfigInfoNode["ClassName"].asString();
if(!jobConfigInfoNode["AttemptInterval"].isNull())
data_.jobConfigInfo.attemptInterval = std::stoi(jobConfigInfoNode["AttemptInterval"].asString());
auto mapTaskXAttrsNode = jobConfigInfoNode["MapTaskXAttrs"];
if(!mapTaskXAttrsNode["PageSize"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.pageSize = std::stoi(mapTaskXAttrsNode["PageSize"].asString());
if(!mapTaskXAttrsNode["TaskMaxAttempt"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.taskMaxAttempt = std::stoi(mapTaskXAttrsNode["TaskMaxAttempt"].asString());
if(!mapTaskXAttrsNode["TaskAttemptInterval"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.taskAttemptInterval = std::stoi(mapTaskXAttrsNode["TaskAttemptInterval"].asString());
if(!mapTaskXAttrsNode["ConsumerSize"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.consumerSize = std::stoi(mapTaskXAttrsNode["ConsumerSize"].asString());
if(!mapTaskXAttrsNode["QueueSize"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.queueSize = std::stoi(mapTaskXAttrsNode["QueueSize"].asString());
if(!mapTaskXAttrsNode["DispatcherSize"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.dispatcherSize = std::stoi(mapTaskXAttrsNode["DispatcherSize"].asString());
if(!mapTaskXAttrsNode["TaskMaxAttempt"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.taskMaxAttempt = std::stoi(mapTaskXAttrsNode["TaskMaxAttempt"].asString());
if(!mapTaskXAttrsNode["TaskAttemptInterval"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.taskAttemptInterval = std::stoi(mapTaskXAttrsNode["TaskAttemptInterval"].asString());
if(!mapTaskXAttrsNode["PageSize"].isNull())
data_.jobConfigInfo.mapTaskXAttrs.pageSize = std::stoi(mapTaskXAttrsNode["PageSize"].asString());
auto timeConfigNode = jobConfigInfoNode["TimeConfig"];
if(!timeConfigNode["TimeType"].isNull())
data_.jobConfigInfo.timeConfig.timeType = std::stoi(timeConfigNode["TimeType"].asString());
if(!timeConfigNode["TimeExpression"].isNull())
data_.jobConfigInfo.timeConfig.timeExpression = timeConfigNode["TimeExpression"].asString();
if(!timeConfigNode["Calendar"].isNull())
data_.jobConfigInfo.timeConfig.calendar = timeConfigNode["Calendar"].asString();
if(!timeConfigNode["TimeType"].isNull())
data_.jobConfigInfo.timeConfig.timeType = std::stoi(timeConfigNode["TimeType"].asString());
if(!timeConfigNode["DataOffset"].isNull())
data_.jobConfigInfo.timeConfig.dataOffset = std::stoi(timeConfigNode["DataOffset"].asString());
if(!timeConfigNode["TimeExpression"].isNull())
data_.jobConfigInfo.timeConfig.timeExpression = timeConfigNode["TimeExpression"].asString();
auto jobMonitorInfoNode = jobConfigInfoNode["JobMonitorInfo"];
auto allContactInfoNode = jobMonitorInfoNode["ContactInfo"]["ContactInfoItem"];
for (auto jobMonitorInfoNodeContactInfoContactInfoItem : allContactInfoNode)
{
Data::JobConfigInfo::JobMonitorInfo::ContactInfoItem contactInfoItemObject;
if(!jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].isNull())
contactInfoItemObject.userName = jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].asString();
if(!jobMonitorInfoNodeContactInfoContactInfoItem["UserPhone"].isNull())
contactInfoItemObject.userPhone = jobMonitorInfoNodeContactInfoContactInfoItem["UserPhone"].asString();
if(!jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].isNull())
contactInfoItemObject.userName = jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].asString();
data_.jobConfigInfo.jobMonitorInfo.contactInfo.push_back(contactInfoItemObject);
}
auto monitorConfigNode = jobMonitorInfoNode["MonitorConfig"];
if(!monitorConfigNode["TimeoutEnable"].isNull())
data_.jobConfigInfo.jobMonitorInfo.monitorConfig.timeoutEnable = monitorConfigNode["TimeoutEnable"].asString() == "true";
if(!monitorConfigNode["Timeout"].isNull())
data_.jobConfigInfo.jobMonitorInfo.monitorConfig.timeout = std::stol(monitorConfigNode["Timeout"].asString());
if(!monitorConfigNode["TimeoutKillEnable"].isNull())
data_.jobConfigInfo.jobMonitorInfo.monitorConfig.timeoutKillEnable = monitorConfigNode["TimeoutKillEnable"].asString() == "true";
if(!monitorConfigNode["FailEnable"].isNull())
data_.jobConfigInfo.jobMonitorInfo.monitorConfig.failEnable = monitorConfigNode["FailEnable"].asString() == "true";
if(!monitorConfigNode["SendChannel"].isNull())
data_.jobConfigInfo.jobMonitorInfo.monitorConfig.sendChannel = monitorConfigNode["SendChannel"].asString();
if(!monitorConfigNode["TimeoutKillEnable"].isNull())
data_.jobConfigInfo.jobMonitorInfo.monitorConfig.timeoutKillEnable = monitorConfigNode["TimeoutKillEnable"].asString() == "true";
if(!monitorConfigNode["TimeoutEnable"].isNull())
data_.jobConfigInfo.jobMonitorInfo.monitorConfig.timeoutEnable = monitorConfigNode["TimeoutEnable"].asString() == "true";
if(!monitorConfigNode["FailEnable"].isNull())
data_.jobConfigInfo.jobMonitorInfo.monitorConfig.failEnable = monitorConfigNode["FailEnable"].asString() == "true";
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())

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

@@ -1,84 +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/GetJobInstanceListRequest.h>
using AlibabaCloud::Schedulerx2::Model::GetJobInstanceListRequest;
GetJobInstanceListRequest::GetJobInstanceListRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInstanceList")
{
setMethod(HttpRequest::Method::Get);
}
GetJobInstanceListRequest::~GetJobInstanceListRequest()
{}
long GetJobInstanceListRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h>
using AlibabaCloud::Schedulerx2::Model::GetJobInstanceListRequest;
GetJobInstanceListRequest::GetJobInstanceListRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInstanceList") {
setMethod(HttpRequest::Method::Get);
}
void GetJobInstanceListRequest::setJobId(long jobId)
{
jobId_ = jobId;
setParameter("JobId", std::to_string(jobId));
GetJobInstanceListRequest::~GetJobInstanceListRequest() {}
long GetJobInstanceListRequest::getJobId() const {
return jobId_;
}
std::string GetJobInstanceListRequest::getNamespaceSource()const
{
return namespaceSource_;
void GetJobInstanceListRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
void GetJobInstanceListRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
std::string GetJobInstanceListRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string GetJobInstanceListRequest::getRegionId()const
{
return regionId_;
void GetJobInstanceListRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void GetJobInstanceListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string GetJobInstanceListRequest::getRegionId() const {
return regionId_;
}
std::string GetJobInstanceListRequest::getGroupId()const
{
return groupId_;
void GetJobInstanceListRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void GetJobInstanceListRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string GetJobInstanceListRequest::getGroupId() const {
return groupId_;
}
std::string GetJobInstanceListRequest::get_Namespace()const
{
return _namespace_;
void GetJobInstanceListRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void GetJobInstanceListRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string GetJobInstanceListRequest::get_Namespace() const {
return _namespace_;
}
void GetJobInstanceListRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

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

@@ -44,32 +44,32 @@ void GetJobInstanceListResult::parse(const std::string &payload)
for (auto dataNodeJobInstanceDetailsJobInstanceDetailsItem : allJobInstanceDetailsNode)
{
Data::JobInstanceDetailsItem jobInstanceDetailsItemObject;
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["InstanceId"].isNull())
jobInstanceDetailsItemObject.instanceId = std::stol(dataNodeJobInstanceDetailsJobInstanceDetailsItem["InstanceId"].asString());
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["JobId"].isNull())
jobInstanceDetailsItemObject.jobId = std::stol(dataNodeJobInstanceDetailsJobInstanceDetailsItem["JobId"].asString());
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Status"].isNull())
jobInstanceDetailsItemObject.status = std::stoi(dataNodeJobInstanceDetailsJobInstanceDetailsItem["Status"].asString());
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["StartTime"].isNull())
jobInstanceDetailsItemObject.startTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["StartTime"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["EndTime"].isNull())
jobInstanceDetailsItemObject.endTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["EndTime"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["ScheduleTime"].isNull())
jobInstanceDetailsItemObject.scheduleTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["ScheduleTime"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["DataTime"].isNull())
jobInstanceDetailsItemObject.dataTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["DataTime"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Executor"].isNull())
jobInstanceDetailsItemObject.executor = dataNodeJobInstanceDetailsJobInstanceDetailsItem["Executor"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["WorkAddr"].isNull())
jobInstanceDetailsItemObject.workAddr = dataNodeJobInstanceDetailsJobInstanceDetailsItem["WorkAddr"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Result"].isNull())
jobInstanceDetailsItemObject.result = dataNodeJobInstanceDetailsJobInstanceDetailsItem["Result"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Progress"].isNull())
jobInstanceDetailsItemObject.progress = dataNodeJobInstanceDetailsJobInstanceDetailsItem["Progress"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Result"].isNull())
jobInstanceDetailsItemObject.result = dataNodeJobInstanceDetailsJobInstanceDetailsItem["Result"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["InstanceId"].isNull())
jobInstanceDetailsItemObject.instanceId = std::stol(dataNodeJobInstanceDetailsJobInstanceDetailsItem["InstanceId"].asString());
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["TimeType"].isNull())
jobInstanceDetailsItemObject.timeType = std::stoi(dataNodeJobInstanceDetailsJobInstanceDetailsItem["TimeType"].asString());
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["TriggerType"].isNull())
jobInstanceDetailsItemObject.triggerType = std::stoi(dataNodeJobInstanceDetailsJobInstanceDetailsItem["TriggerType"].asString());
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["EndTime"].isNull())
jobInstanceDetailsItemObject.endTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["EndTime"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["StartTime"].isNull())
jobInstanceDetailsItemObject.startTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["StartTime"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Executor"].isNull())
jobInstanceDetailsItemObject.executor = dataNodeJobInstanceDetailsJobInstanceDetailsItem["Executor"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["JobId"].isNull())
jobInstanceDetailsItemObject.jobId = std::stol(dataNodeJobInstanceDetailsJobInstanceDetailsItem["JobId"].asString());
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["ScheduleTime"].isNull())
jobInstanceDetailsItemObject.scheduleTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["ScheduleTime"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["DataTime"].isNull())
jobInstanceDetailsItemObject.dataTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["DataTime"].asString();
if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["WorkAddr"].isNull())
jobInstanceDetailsItemObject.workAddr = dataNodeJobInstanceDetailsJobInstanceDetailsItem["WorkAddr"].asString();
data_.jobInstanceDetails.push_back(jobInstanceDetailsItemObject);
}
if(!value["Code"].isNull())

94
schedulerx2/src/model/GetJobInstanceRequest.cc
View File

@@ -1,84 +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/GetJobInstanceRequest.h>
using AlibabaCloud::Schedulerx2::Model::GetJobInstanceRequest;
GetJobInstanceRequest::GetJobInstanceRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInstance")
{
setMethod(HttpRequest::Method::Get);
}
GetJobInstanceRequest::~GetJobInstanceRequest()
{}
long GetJobInstanceRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/schedulerx2/model/GetJobInstanceRequest.h>
using AlibabaCloud::Schedulerx2::Model::GetJobInstanceRequest;
GetJobInstanceRequest::GetJobInstanceRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInstance") {
setMethod(HttpRequest::Method::Get);
}
void GetJobInstanceRequest::setJobId(long jobId)
{
jobId_ = jobId;
setParameter("JobId", std::to_string(jobId));
GetJobInstanceRequest::~GetJobInstanceRequest() {}
long GetJobInstanceRequest::getJobId() const {
return jobId_;
}
std::string GetJobInstanceRequest::getNamespaceSource()const
{
return namespaceSource_;
void GetJobInstanceRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
void GetJobInstanceRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
std::string GetJobInstanceRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string GetJobInstanceRequest::getGroupId()const
{
return groupId_;
void GetJobInstanceRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void GetJobInstanceRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string GetJobInstanceRequest::getGroupId() const {
return groupId_;
}
std::string GetJobInstanceRequest::get_Namespace()const
{
return _namespace_;
void GetJobInstanceRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void GetJobInstanceRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string GetJobInstanceRequest::get_Namespace() const {
return _namespace_;
}
long GetJobInstanceRequest::getJobInstanceId()const
{
return jobInstanceId_;
void GetJobInstanceRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void GetJobInstanceRequest::setJobInstanceId(long jobInstanceId)
{
jobInstanceId_ = jobInstanceId;
setParameter("JobInstanceId", std::to_string(jobInstanceId));
long GetJobInstanceRequest::getJobInstanceId() const {
return jobInstanceId_;
}
void GetJobInstanceRequest::setJobInstanceId(long jobInstanceId) {
jobInstanceId_ = jobInstanceId;
setParameter(std::string("JobInstanceId"), std::to_string(jobInstanceId));
}

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

@@ -41,32 +41,32 @@ void GetJobInstanceResult::parse(const std::string &payload)
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto jobInstanceDetailNode = dataNode["JobInstanceDetail"];
if(!jobInstanceDetailNode["InstanceId"].isNull())
data_.jobInstanceDetail.instanceId = std::stol(jobInstanceDetailNode["InstanceId"].asString());
if(!jobInstanceDetailNode["JobId"].isNull())
data_.jobInstanceDetail.jobId = std::stol(jobInstanceDetailNode["JobId"].asString());
if(!jobInstanceDetailNode["Status"].isNull())
data_.jobInstanceDetail.status = std::stoi(jobInstanceDetailNode["Status"].asString());
if(!jobInstanceDetailNode["StartTime"].isNull())
data_.jobInstanceDetail.startTime = jobInstanceDetailNode["StartTime"].asString();
if(!jobInstanceDetailNode["EndTime"].isNull())
data_.jobInstanceDetail.endTime = jobInstanceDetailNode["EndTime"].asString();
if(!jobInstanceDetailNode["ScheduleTime"].isNull())
data_.jobInstanceDetail.scheduleTime = jobInstanceDetailNode["ScheduleTime"].asString();
if(!jobInstanceDetailNode["DataTime"].isNull())
data_.jobInstanceDetail.dataTime = jobInstanceDetailNode["DataTime"].asString();
if(!jobInstanceDetailNode["Executor"].isNull())
data_.jobInstanceDetail.executor = jobInstanceDetailNode["Executor"].asString();
if(!jobInstanceDetailNode["WorkAddr"].isNull())
data_.jobInstanceDetail.workAddr = jobInstanceDetailNode["WorkAddr"].asString();
if(!jobInstanceDetailNode["Result"].isNull())
data_.jobInstanceDetail.result = jobInstanceDetailNode["Result"].asString();
if(!jobInstanceDetailNode["Progress"].isNull())
data_.jobInstanceDetail.progress = jobInstanceDetailNode["Progress"].asString();
if(!jobInstanceDetailNode["Result"].isNull())
data_.jobInstanceDetail.result = jobInstanceDetailNode["Result"].asString();
if(!jobInstanceDetailNode["InstanceId"].isNull())
data_.jobInstanceDetail.instanceId = std::stol(jobInstanceDetailNode["InstanceId"].asString());
if(!jobInstanceDetailNode["TimeType"].isNull())
data_.jobInstanceDetail.timeType = std::stoi(jobInstanceDetailNode["TimeType"].asString());
if(!jobInstanceDetailNode["TriggerType"].isNull())
data_.jobInstanceDetail.triggerType = std::stoi(jobInstanceDetailNode["TriggerType"].asString());
if(!jobInstanceDetailNode["EndTime"].isNull())
data_.jobInstanceDetail.endTime = jobInstanceDetailNode["EndTime"].asString();
if(!jobInstanceDetailNode["StartTime"].isNull())
data_.jobInstanceDetail.startTime = jobInstanceDetailNode["StartTime"].asString();
if(!jobInstanceDetailNode["Executor"].isNull())
data_.jobInstanceDetail.executor = jobInstanceDetailNode["Executor"].asString();
if(!jobInstanceDetailNode["JobId"].isNull())
data_.jobInstanceDetail.jobId = std::stol(jobInstanceDetailNode["JobId"].asString());
if(!jobInstanceDetailNode["ScheduleTime"].isNull())
data_.jobInstanceDetail.scheduleTime = jobInstanceDetailNode["ScheduleTime"].asString();
if(!jobInstanceDetailNode["DataTime"].isNull())
data_.jobInstanceDetail.dataTime = jobInstanceDetailNode["DataTime"].asString();
if(!jobInstanceDetailNode["WorkAddr"].isNull())
data_.jobInstanceDetail.workAddr = jobInstanceDetailNode["WorkAddr"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())

72
schedulerx2/src/model/GetWorkFlowRequest.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/GetWorkFlowRequest.h>
using AlibabaCloud::Schedulerx2::Model::GetWorkFlowRequest;
GetWorkFlowRequest::GetWorkFlowRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "GetWorkFlow") {
setMethod(HttpRequest::Method::Get);
}
GetWorkFlowRequest::~GetWorkFlowRequest() {}
std::string GetWorkFlowRequest::getNamespaceSource() const {
return namespaceSource_;
}
void GetWorkFlowRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
std::string GetWorkFlowRequest::getGroupId() const {
return groupId_;
}
void GetWorkFlowRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string GetWorkFlowRequest::getRegionId() const {
return regionId_;
}
void GetWorkFlowRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string GetWorkFlowRequest::get_Namespace() const {
return _namespace_;
}
void GetWorkFlowRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
long GetWorkFlowRequest::getWorkflowId() const {
return workflowId_;
}
void GetWorkFlowRequest::setWorkflowId(long workflowId) {
workflowId_ = workflowId;
setParameter(std::string("WorkflowId"), std::to_string(workflowId));
}

107
schedulerx2/src/model/GetWorkFlowResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/GetWorkFlowResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Schedulerx2;
using namespace AlibabaCloud::Schedulerx2::Model;
GetWorkFlowResult::GetWorkFlowResult() :
ServiceResult()
{}
GetWorkFlowResult::GetWorkFlowResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetWorkFlowResult::~GetWorkFlowResult()
{}
void GetWorkFlowResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto workFlowInfoNode = dataNode["WorkFlowInfo"];
if(!workFlowInfoNode["WorkflowId"].isNull())
data_.workFlowInfo.workflowId = std::stol(workFlowInfoNode["WorkflowId"].asString());
if(!workFlowInfoNode["Name"].isNull())
data_.workFlowInfo.name = workFlowInfoNode["Name"].asString();
if(!workFlowInfoNode["Description"].isNull())
data_.workFlowInfo.description = workFlowInfoNode["Description"].asString();
if(!workFlowInfoNode["Status"].isNull())
data_.workFlowInfo.status = workFlowInfoNode["Status"].asString();
if(!workFlowInfoNode["TimeType"].isNull())
data_.workFlowInfo.timeType = workFlowInfoNode["TimeType"].asString();
if(!workFlowInfoNode["TimeExpression"].isNull())
data_.workFlowInfo.timeExpression = workFlowInfoNode["TimeExpression"].asString();
auto workFlowNodeInfoNode = dataNode["WorkFlowNodeInfo"];
auto allNodesNode = workFlowNodeInfoNode["Nodes"]["Node"];
for (auto workFlowNodeInfoNodeNodesNode : allNodesNode)
{
Data::WorkFlowNodeInfo::Node nodeObject;
if(!workFlowNodeInfoNodeNodesNode["Id"].isNull())
nodeObject.id = std::stol(workFlowNodeInfoNodeNodesNode["Id"].asString());
if(!workFlowNodeInfoNodeNodesNode["Label"].isNull())
nodeObject.label = workFlowNodeInfoNodeNodesNode["Label"].asString();
if(!workFlowNodeInfoNodeNodesNode["Status"].isNull())
nodeObject.status = std::stoi(workFlowNodeInfoNodeNodesNode["Status"].asString());
data_.workFlowNodeInfo.nodes.push_back(nodeObject);
}
auto allEdgesNode = workFlowNodeInfoNode["Edges"]["Edge"];
for (auto workFlowNodeInfoNodeEdgesEdge : allEdgesNode)
{
Data::WorkFlowNodeInfo::Edge edgeObject;
if(!workFlowNodeInfoNodeEdgesEdge["Source"].isNull())
edgeObject.source = std::stol(workFlowNodeInfoNodeEdgesEdge["Source"].asString());
if(!workFlowNodeInfoNodeEdgesEdge["Target"].isNull())
edgeObject.target = std::stol(workFlowNodeInfoNodeEdgesEdge["Target"].asString());
data_.workFlowNodeInfo.edges.push_back(edgeObject);
}
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string GetWorkFlowResult::getMessage()const
{
return message_;
}
GetWorkFlowResult::Data GetWorkFlowResult::getData()const
{
return data_;
}
int GetWorkFlowResult::getCode()const
{
return code_;
}
bool GetWorkFlowResult::getSuccess()const
{
return success_;
}

118
schedulerx2/src/model/GrantPermissionRequest.cc
View File

@@ -1,106 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/schedulerx2/model/GrantPermissionRequest.h>
using AlibabaCloud::Schedulerx2::Model::GrantPermissionRequest;
GrantPermissionRequest::GrantPermissionRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "GrantPermission")
{
setMethod(HttpRequest::Method::Post);
}
GrantPermissionRequest::~GrantPermissionRequest()
{}
std::string GrantPermissionRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/GrantPermissionRequest.h>
using AlibabaCloud::Schedulerx2::Model::GrantPermissionRequest;
GrantPermissionRequest::GrantPermissionRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "GrantPermission") {
setMethod(HttpRequest::Method::Post);
}
void GrantPermissionRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
GrantPermissionRequest::~GrantPermissionRequest() {}
std::string GrantPermissionRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string GrantPermissionRequest::getGroupId()const
{
return groupId_;
void GrantPermissionRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void GrantPermissionRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string GrantPermissionRequest::getGroupId() const {
return groupId_;
}
std::string GrantPermissionRequest::getUserId()const
{
return userId_;
void GrantPermissionRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void GrantPermissionRequest::setUserId(const std::string& userId)
{
userId_ = userId;
setParameter("UserId", userId);
std::string GrantPermissionRequest::getUserId() const {
return userId_;
}
bool GrantPermissionRequest::getGrantOption()const
{
return grantOption_;
void GrantPermissionRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}
void GrantPermissionRequest::setGrantOption(bool grantOption)
{
grantOption_ = grantOption;
setParameter("GrantOption", grantOption ? "true" : "false");
bool GrantPermissionRequest::getGrantOption() const {
return grantOption_;
}
std::string GrantPermissionRequest::getRegionId()const
{
return regionId_;
void GrantPermissionRequest::setGrantOption(bool grantOption) {
grantOption_ = grantOption;
setParameter(std::string("GrantOption"), grantOption ? "true" : "false");
}
void GrantPermissionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string GrantPermissionRequest::getRegionId() const {
return regionId_;
}
std::string GrantPermissionRequest::get_Namespace()const
{
return _namespace_;
void GrantPermissionRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void GrantPermissionRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string GrantPermissionRequest::get_Namespace() const {
return _namespace_;
}
std::string GrantPermissionRequest::getUserName()const
{
return userName_;
void GrantPermissionRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void GrantPermissionRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setParameter("UserName", userName);
std::string GrantPermissionRequest::getUserName() const {
return userName_;
}
void GrantPermissionRequest::setUserName(const std::string &userName) {
userName_ = userName;
setParameter(std::string("UserName"), userName);
}

4
schedulerx2/src/model/GrantPermissionResult.cc
View File

@@ -41,10 +41,10 @@ void GrantPermissionResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

70
schedulerx2/src/model/ListGroupsRequest.cc
View File

@@ -1,62 +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.
*/
#include <alibabacloud/schedulerx2/model/ListGroupsRequest.h>
using AlibabaCloud::Schedulerx2::Model::ListGroupsRequest;
ListGroupsRequest::ListGroupsRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "ListGroups")
{
setMethod(HttpRequest::Method::Get);
}
ListGroupsRequest::~ListGroupsRequest()
{}
std::string ListGroupsRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/ListGroupsRequest.h>
using AlibabaCloud::Schedulerx2::Model::ListGroupsRequest;
ListGroupsRequest::ListGroupsRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "ListGroups") {
setMethod(HttpRequest::Method::Get);
}
void ListGroupsRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
ListGroupsRequest::~ListGroupsRequest() {}
std::string ListGroupsRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string ListGroupsRequest::getRegionId()const
{
return regionId_;
void ListGroupsRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void ListGroupsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ListGroupsRequest::getRegionId() const {
return regionId_;
}
std::string ListGroupsRequest::get_Namespace()const
{
return _namespace_;
void ListGroupsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListGroupsRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string ListGroupsRequest::get_Namespace() const {
return _namespace_;
}
void ListGroupsRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

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

@@ -46,12 +46,12 @@ void ListGroupsResult::parse(const std::string &payload)
Data::AppGroup appGroupObject;
if(!dataNodeAppGroupsAppGroup["AppName"].isNull())
appGroupObject.appName = dataNodeAppGroupsAppGroup["AppName"].asString();
if(!dataNodeAppGroupsAppGroup["GroupId"].isNull())
appGroupObject.groupId = dataNodeAppGroupsAppGroup["GroupId"].asString();
if(!dataNodeAppGroupsAppGroup["AppKey"].isNull())
appGroupObject.appKey = dataNodeAppGroupsAppGroup["AppKey"].asString();
if(!dataNodeAppGroupsAppGroup["Description"].isNull())
appGroupObject.description = dataNodeAppGroupsAppGroup["Description"].asString();
if(!dataNodeAppGroupsAppGroup["GroupId"].isNull())
appGroupObject.groupId = dataNodeAppGroupsAppGroup["GroupId"].asString();
data_.appGroups.push_back(appGroupObject);
}
if(!value["Code"].isNull())

106
schedulerx2/src/model/ListJobsRequest.cc
View File

@@ -1,95 +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/ListJobsRequest.h>
using AlibabaCloud::Schedulerx2::Model::ListJobsRequest;
ListJobsRequest::ListJobsRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "ListJobs")
{
setMethod(HttpRequest::Method::Get);
}
ListJobsRequest::~ListJobsRequest()
{}
std::string ListJobsRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/ListJobsRequest.h>
using AlibabaCloud::Schedulerx2::Model::ListJobsRequest;
ListJobsRequest::ListJobsRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "ListJobs") {
setMethod(HttpRequest::Method::Get);
}
void ListJobsRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
ListJobsRequest::~ListJobsRequest() {}
std::string ListJobsRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string ListJobsRequest::getRegionId()const
{
return regionId_;
void ListJobsRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void ListJobsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ListJobsRequest::getRegionId() const {
return regionId_;
}
std::string ListJobsRequest::getGroupId()const
{
return groupId_;
void ListJobsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListJobsRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string ListJobsRequest::getGroupId() const {
return groupId_;
}
std::string ListJobsRequest::get_Namespace()const
{
return _namespace_;
void ListJobsRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void ListJobsRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string ListJobsRequest::get_Namespace() const {
return _namespace_;
}
std::string ListJobsRequest::getJobName()const
{
return jobName_;
void ListJobsRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void ListJobsRequest::setJobName(const std::string& jobName)
{
jobName_ = jobName;
setParameter("JobName", jobName);
std::string ListJobsRequest::getJobName() const {
return jobName_;
}
std::string ListJobsRequest::getStatus()const
{
return status_;
void ListJobsRequest::setJobName(const std::string &jobName) {
jobName_ = jobName;
setParameter(std::string("JobName"), jobName);
}
void ListJobsRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
std::string ListJobsRequest::getStatus() const {
return status_;
}
void ListJobsRequest::setStatus(const std::string &status) {
status_ = status;
setParameter(std::string("Status"), status);
}

72
schedulerx2/src/model/ListJobsResult.cc
View File

@@ -44,74 +44,74 @@ void ListJobsResult::parse(const std::string &payload)
for (auto dataNodeJobsJob : allJobsNode)
{
Data::Job jobObject;
if(!dataNodeJobsJob["ClassName"].isNull())
jobObject.className = dataNodeJobsJob["ClassName"].asString();
if(!dataNodeJobsJob["JarUrl"].isNull())
jobObject.jarUrl = dataNodeJobsJob["JarUrl"].asString();
if(!dataNodeJobsJob["Content"].isNull())
jobObject.content = dataNodeJobsJob["Content"].asString();
if(!dataNodeJobsJob["Name"].isNull())
jobObject.name = dataNodeJobsJob["Name"].asString();
if(!dataNodeJobsJob["Description"].isNull())
jobObject.description = dataNodeJobsJob["Description"].asString();
if(!dataNodeJobsJob["Status"].isNull())
jobObject.status = std::stoi(dataNodeJobsJob["Status"].asString());
if(!dataNodeJobsJob["ExecuteMode"].isNull())
jobObject.executeMode = dataNodeJobsJob["ExecuteMode"].asString();
if(!dataNodeJobsJob["Parameters"].isNull())
jobObject.parameters = dataNodeJobsJob["Parameters"].asString();
if(!dataNodeJobsJob["MaxConcurrency"].isNull())
jobObject.maxConcurrency = dataNodeJobsJob["MaxConcurrency"].asString();
if(!dataNodeJobsJob["JarUrl"].isNull())
jobObject.jarUrl = dataNodeJobsJob["JarUrl"].asString();
if(!dataNodeJobsJob["MaxAttempt"].isNull())
jobObject.maxAttempt = std::stoi(dataNodeJobsJob["MaxAttempt"].asString());
if(!dataNodeJobsJob["AttemptInterval"].isNull())
jobObject.attemptInterval = std::stoi(dataNodeJobsJob["AttemptInterval"].asString());
if(!dataNodeJobsJob["Parameters"].isNull())
jobObject.parameters = dataNodeJobsJob["Parameters"].asString();
if(!dataNodeJobsJob["Description"].isNull())
jobObject.description = dataNodeJobsJob["Description"].asString();
if(!dataNodeJobsJob["JobId"].isNull())
jobObject.jobId = std::stol(dataNodeJobsJob["JobId"].asString());
if(!dataNodeJobsJob["ExecuteMode"].isNull())
jobObject.executeMode = dataNodeJobsJob["ExecuteMode"].asString();
if(!dataNodeJobsJob["MaxConcurrency"].isNull())
jobObject.maxConcurrency = dataNodeJobsJob["MaxConcurrency"].asString();
if(!dataNodeJobsJob["Name"].isNull())
jobObject.name = dataNodeJobsJob["Name"].asString();
if(!dataNodeJobsJob["ClassName"].isNull())
jobObject.className = dataNodeJobsJob["ClassName"].asString();
if(!dataNodeJobsJob["Content"].isNull())
jobObject.content = dataNodeJobsJob["Content"].asString();
if(!dataNodeJobsJob["AttemptInterval"].isNull())
jobObject.attemptInterval = std::stoi(dataNodeJobsJob["AttemptInterval"].asString());
auto mapTaskXAttrsNode = value["MapTaskXAttrs"];
if(!mapTaskXAttrsNode["PageSize"].isNull())
jobObject.mapTaskXAttrs.pageSize = std::stoi(mapTaskXAttrsNode["PageSize"].asString());
if(!mapTaskXAttrsNode["TaskMaxAttempt"].isNull())
jobObject.mapTaskXAttrs.taskMaxAttempt = std::stoi(mapTaskXAttrsNode["TaskMaxAttempt"].asString());
if(!mapTaskXAttrsNode["TaskAttemptInterval"].isNull())
jobObject.mapTaskXAttrs.taskAttemptInterval = std::stoi(mapTaskXAttrsNode["TaskAttemptInterval"].asString());
if(!mapTaskXAttrsNode["ConsumerSize"].isNull())
jobObject.mapTaskXAttrs.consumerSize = std::stoi(mapTaskXAttrsNode["ConsumerSize"].asString());
if(!mapTaskXAttrsNode["QueueSize"].isNull())
jobObject.mapTaskXAttrs.queueSize = std::stoi(mapTaskXAttrsNode["QueueSize"].asString());
if(!mapTaskXAttrsNode["DispatcherSize"].isNull())
jobObject.mapTaskXAttrs.dispatcherSize = std::stoi(mapTaskXAttrsNode["DispatcherSize"].asString());
if(!mapTaskXAttrsNode["TaskMaxAttempt"].isNull())
jobObject.mapTaskXAttrs.taskMaxAttempt = std::stoi(mapTaskXAttrsNode["TaskMaxAttempt"].asString());
if(!mapTaskXAttrsNode["TaskAttemptInterval"].isNull())
jobObject.mapTaskXAttrs.taskAttemptInterval = std::stoi(mapTaskXAttrsNode["TaskAttemptInterval"].asString());
if(!mapTaskXAttrsNode["PageSize"].isNull())
jobObject.mapTaskXAttrs.pageSize = std::stoi(mapTaskXAttrsNode["PageSize"].asString());
auto timeConfigNode = value["TimeConfig"];
if(!timeConfigNode["TimeType"].isNull())
jobObject.timeConfig.timeType = std::stoi(timeConfigNode["TimeType"].asString());
if(!timeConfigNode["TimeExpression"].isNull())
jobObject.timeConfig.timeExpression = timeConfigNode["TimeExpression"].asString();
if(!timeConfigNode["Calendar"].isNull())
jobObject.timeConfig.calendar = timeConfigNode["Calendar"].asString();
if(!timeConfigNode["TimeType"].isNull())
jobObject.timeConfig.timeType = std::stoi(timeConfigNode["TimeType"].asString());
if(!timeConfigNode["DataOffset"].isNull())
jobObject.timeConfig.dataOffset = std::stoi(timeConfigNode["DataOffset"].asString());
if(!timeConfigNode["TimeExpression"].isNull())
jobObject.timeConfig.timeExpression = timeConfigNode["TimeExpression"].asString();
auto jobMonitorInfoNode = value["JobMonitorInfo"];
auto allContactInfoNode = jobMonitorInfoNode["ContactInfo"]["ContactInfoItem"];
for (auto jobMonitorInfoNodeContactInfoContactInfoItem : allContactInfoNode)
{
Data::Job::JobMonitorInfo::ContactInfoItem contactInfoItemObject;
if(!jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].isNull())
contactInfoItemObject.userName = jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].asString();
if(!jobMonitorInfoNodeContactInfoContactInfoItem["UserPhone"].isNull())
contactInfoItemObject.userPhone = jobMonitorInfoNodeContactInfoContactInfoItem["UserPhone"].asString();
if(!jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].isNull())
contactInfoItemObject.userName = jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].asString();
jobObject.jobMonitorInfo.contactInfo.push_back(contactInfoItemObject);
}
auto monitorConfigNode = jobMonitorInfoNode["MonitorConfig"];
if(!monitorConfigNode["TimeoutEnable"].isNull())
jobObject.jobMonitorInfo.monitorConfig.timeoutEnable = monitorConfigNode["TimeoutEnable"].asString() == "true";
if(!monitorConfigNode["Timeout"].isNull())
jobObject.jobMonitorInfo.monitorConfig.timeout = std::stol(monitorConfigNode["Timeout"].asString());
if(!monitorConfigNode["TimeoutKillEnable"].isNull())
jobObject.jobMonitorInfo.monitorConfig.timeoutKillEnable = monitorConfigNode["TimeoutKillEnable"].asString() == "true";
if(!monitorConfigNode["FailEnable"].isNull())
jobObject.jobMonitorInfo.monitorConfig.failEnable = monitorConfigNode["FailEnable"].asString() == "true";
if(!monitorConfigNode["SendChannel"].isNull())
jobObject.jobMonitorInfo.monitorConfig.sendChannel = monitorConfigNode["SendChannel"].asString();
if(!monitorConfigNode["TimeoutKillEnable"].isNull())
jobObject.jobMonitorInfo.monitorConfig.timeoutKillEnable = monitorConfigNode["TimeoutKillEnable"].asString() == "true";
if(!monitorConfigNode["TimeoutEnable"].isNull())
jobObject.jobMonitorInfo.monitorConfig.timeoutEnable = monitorConfigNode["TimeoutEnable"].asString() == "true";
if(!monitorConfigNode["FailEnable"].isNull())
jobObject.jobMonitorInfo.monitorConfig.failEnable = monitorConfigNode["FailEnable"].asString() == "true";
data_.jobs.push_back(jobObject);
}
if(!value["Code"].isNull())

46
schedulerx2/src/model/ListNamespacesRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* 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/ListNamespacesRequest.h>
using AlibabaCloud::Schedulerx2::Model::ListNamespacesRequest;
ListNamespacesRequest::ListNamespacesRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "ListNamespaces")
{
setMethod(HttpRequest::Method::Get);
}
ListNamespacesRequest::~ListNamespacesRequest()
{}
std::string ListNamespacesRequest::getRegionId()const
{
return regionId_;
*/
#include <alibabacloud/schedulerx2/model/ListNamespacesRequest.h>
using AlibabaCloud::Schedulerx2::Model::ListNamespacesRequest;
ListNamespacesRequest::ListNamespacesRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "ListNamespaces") {
setMethod(HttpRequest::Method::Get);
}
void ListNamespacesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
ListNamespacesRequest::~ListNamespacesRequest() {}
std::string ListNamespacesRequest::getRegionId() const {
return regionId_;
}
void ListNamespacesRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}

8
schedulerx2/src/model/ListNamespacesResult.cc
View File

@@ -46,18 +46,18 @@ void ListNamespacesResult::parse(const std::string &payload)
Data::_Namespace _namespaceObject;
if(!dataNodeNamespacesNamespace["Name"].isNull())
_namespaceObject.name = dataNodeNamespacesNamespace["Name"].asString();
if(!dataNodeNamespacesNamespace["UId"].isNull())
_namespaceObject.uId = dataNodeNamespacesNamespace["UId"].asString();
if(!dataNodeNamespacesNamespace["Description"].isNull())
_namespaceObject.description = dataNodeNamespacesNamespace["Description"].asString();
if(!dataNodeNamespacesNamespace["UId"].isNull())
_namespaceObject.uId = dataNodeNamespacesNamespace["UId"].asString();
data_.namespaces.push_back(_namespaceObject);
}
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

94
schedulerx2/src/model/RevokePermissionRequest.cc
View File

@@ -1,84 +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/RevokePermissionRequest.h>
using AlibabaCloud::Schedulerx2::Model::RevokePermissionRequest;
RevokePermissionRequest::RevokePermissionRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "RevokePermission")
{
setMethod(HttpRequest::Method::Post);
}
RevokePermissionRequest::~RevokePermissionRequest()
{}
std::string RevokePermissionRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/RevokePermissionRequest.h>
using AlibabaCloud::Schedulerx2::Model::RevokePermissionRequest;
RevokePermissionRequest::RevokePermissionRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "RevokePermission") {
setMethod(HttpRequest::Method::Post);
}
void RevokePermissionRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
RevokePermissionRequest::~RevokePermissionRequest() {}
std::string RevokePermissionRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string RevokePermissionRequest::getRegionId()const
{
return regionId_;
void RevokePermissionRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void RevokePermissionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string RevokePermissionRequest::getRegionId() const {
return regionId_;
}
std::string RevokePermissionRequest::getGroupId()const
{
return groupId_;
void RevokePermissionRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void RevokePermissionRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string RevokePermissionRequest::getGroupId() const {
return groupId_;
}
std::string RevokePermissionRequest::get_Namespace()const
{
return _namespace_;
void RevokePermissionRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void RevokePermissionRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string RevokePermissionRequest::get_Namespace() const {
return _namespace_;
}
std::string RevokePermissionRequest::getUserId()const
{
return userId_;
void RevokePermissionRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}
void RevokePermissionRequest::setUserId(const std::string& userId)
{
userId_ = userId;
setParameter("UserId", userId);
std::string RevokePermissionRequest::getUserId() const {
return userId_;
}
void RevokePermissionRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}

4
schedulerx2/src/model/RevokePermissionResult.cc
View File

@@ -41,10 +41,10 @@ void RevokePermissionResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

106
schedulerx2/src/model/StopInstanceRequest.cc
View File

@@ -1,95 +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/StopInstanceRequest.h>
using AlibabaCloud::Schedulerx2::Model::StopInstanceRequest;
StopInstanceRequest::StopInstanceRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "StopInstance")
{
setMethod(HttpRequest::Method::Get);
}
StopInstanceRequest::~StopInstanceRequest()
{}
long StopInstanceRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/schedulerx2/model/StopInstanceRequest.h>
using AlibabaCloud::Schedulerx2::Model::StopInstanceRequest;
StopInstanceRequest::StopInstanceRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "StopInstance") {
setMethod(HttpRequest::Method::Get);
}
void StopInstanceRequest::setJobId(long jobId)
{
jobId_ = jobId;
setParameter("JobId", std::to_string(jobId));
StopInstanceRequest::~StopInstanceRequest() {}
long StopInstanceRequest::getJobId() const {
return jobId_;
}
std::string StopInstanceRequest::getNamespaceSource()const
{
return namespaceSource_;
void StopInstanceRequest::setJobId(long jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), std::to_string(jobId));
}
void StopInstanceRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setParameter("NamespaceSource", namespaceSource);
std::string StopInstanceRequest::getNamespaceSource() const {
return namespaceSource_;
}
long StopInstanceRequest::getInstanceId()const
{
return instanceId_;
void StopInstanceRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setParameter(std::string("NamespaceSource"), namespaceSource);
}
void StopInstanceRequest::setInstanceId(long instanceId)
{
instanceId_ = instanceId;
setParameter("InstanceId", std::to_string(instanceId));
long StopInstanceRequest::getInstanceId() const {
return instanceId_;
}
std::string StopInstanceRequest::getRegionId()const
{
return regionId_;
void StopInstanceRequest::setInstanceId(long instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), std::to_string(instanceId));
}
void StopInstanceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string StopInstanceRequest::getRegionId() const {
return regionId_;
}
std::string StopInstanceRequest::getGroupId()const
{
return groupId_;
void StopInstanceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void StopInstanceRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
std::string StopInstanceRequest::getGroupId() const {
return groupId_;
}
std::string StopInstanceRequest::get_Namespace()const
{
return _namespace_;
void StopInstanceRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
void StopInstanceRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setParameter("_Namespace", _namespace);
std::string StopInstanceRequest::get_Namespace() const {
return _namespace_;
}
void StopInstanceRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

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

@@ -1,375 +1,311 @@
/*
* 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/UpdateJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::UpdateJobRequest;
UpdateJobRequest::UpdateJobRequest() :
RpcServiceRequest("schedulerx2", "2019-04-30", "UpdateJob")
{
setMethod(HttpRequest::Method::Post);
}
UpdateJobRequest::~UpdateJobRequest()
{}
std::string UpdateJobRequest::getNamespaceSource()const
{
return namespaceSource_;
*/
#include <alibabacloud/schedulerx2/model/UpdateJobRequest.h>
using AlibabaCloud::Schedulerx2::Model::UpdateJobRequest;
UpdateJobRequest::UpdateJobRequest()
: RpcServiceRequest("schedulerx2", "2019-04-30", "UpdateJob") {
setMethod(HttpRequest::Method::Post);
}
void UpdateJobRequest::setNamespaceSource(const std::string& namespaceSource)
{
namespaceSource_ = namespaceSource;
setBodyParameter("NamespaceSource", namespaceSource);
UpdateJobRequest::~UpdateJobRequest() {}
std::string UpdateJobRequest::getNamespaceSource() const {
return namespaceSource_;
}
std::string UpdateJobRequest::getDescription()const
{
return description_;
void UpdateJobRequest::setNamespaceSource(const std::string &namespaceSource) {
namespaceSource_ = namespaceSource;
setBodyParameter(std::string("NamespaceSource"), namespaceSource);
}
void UpdateJobRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
std::string UpdateJobRequest::getDescription() const {
return description_;
}
int UpdateJobRequest::getAttemptInterval()const
{
return attemptInterval_;
void UpdateJobRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
void UpdateJobRequest::setAttemptInterval(int attemptInterval)
{
attemptInterval_ = attemptInterval;
setBodyParameter("AttemptInterval", std::to_string(attemptInterval));
int UpdateJobRequest::getAttemptInterval() const {
return attemptInterval_;
}
std::string UpdateJobRequest::getContent()const
{
return content_;
void UpdateJobRequest::setAttemptInterval(int attemptInterval) {
attemptInterval_ = attemptInterval;
setBodyParameter(std::string("AttemptInterval"), std::to_string(attemptInterval));
}
void UpdateJobRequest::setContent(const std::string& content)
{
content_ = content;
setBodyParameter("Content", content);
std::string UpdateJobRequest::getContent() const {
return content_;
}
long UpdateJobRequest::getTimeout()const
{
return timeout_;
void UpdateJobRequest::setContent(const std::string &content) {
content_ = content;
setBodyParameter(std::string("Content"), content);
}
void UpdateJobRequest::setTimeout(long timeout)
{
timeout_ = timeout;
setBodyParameter("Timeout", std::to_string(timeout));
long UpdateJobRequest::getTimeout() const {
return timeout_;
}
bool UpdateJobRequest::getTimeoutKillEnable()const
{
return timeoutKillEnable_;
void UpdateJobRequest::setTimeout(long timeout) {
timeout_ = timeout;
setBodyParameter(std::string("Timeout"), std::to_string(timeout));
}
void UpdateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable)
{
timeoutKillEnable_ = timeoutKillEnable;
setBodyParameter("TimeoutKillEnable", timeoutKillEnable ? "true" : "false");
bool UpdateJobRequest::getTimeoutKillEnable() const {
return timeoutKillEnable_;
}
long UpdateJobRequest::getJobId()const
{
return jobId_;
void UpdateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable) {
timeoutKillEnable_ = timeoutKillEnable;
setBodyParameter(std::string("TimeoutKillEnable"), timeoutKillEnable ? "true" : "false");
}
void UpdateJobRequest::setJobId(long jobId)
{
jobId_ = jobId;
setBodyParameter("JobId", std::to_string(jobId));
long UpdateJobRequest::getJobId() const {
return jobId_;
}
std::string UpdateJobRequest::getRegionId()const
{
return regionId_;
void UpdateJobRequest::setJobId(long jobId) {
jobId_ = jobId;
setBodyParameter(std::string("JobId"), std::to_string(jobId));
}
void UpdateJobRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string UpdateJobRequest::getRegionId() const {
return regionId_;
}
int UpdateJobRequest::getPageSize()const
{
return pageSize_;
void UpdateJobRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void UpdateJobRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setBodyParameter("PageSize", std::to_string(pageSize));
int UpdateJobRequest::getPageSize() const {
return pageSize_;
}
int UpdateJobRequest::getConsumerSize()const
{
return consumerSize_;
void UpdateJobRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
}
void UpdateJobRequest::setConsumerSize(int consumerSize)
{
consumerSize_ = consumerSize;
setBodyParameter("ConsumerSize", std::to_string(consumerSize));
int UpdateJobRequest::getConsumerSize() const {
return consumerSize_;
}
std::string UpdateJobRequest::getJarUrl()const
{
return jarUrl_;
void UpdateJobRequest::setConsumerSize(int consumerSize) {
consumerSize_ = consumerSize;
setBodyParameter(std::string("ConsumerSize"), std::to_string(consumerSize));
}
void UpdateJobRequest::setJarUrl(const std::string& jarUrl)
{
jarUrl_ = jarUrl;
setBodyParameter("JarUrl", jarUrl);
std::string UpdateJobRequest::getJarUrl() const {
return jarUrl_;
}
std::string UpdateJobRequest::getCalendar()const
{
return calendar_;
void UpdateJobRequest::setJarUrl(const std::string &jarUrl) {
jarUrl_ = jarUrl;
setBodyParameter(std::string("JarUrl"), jarUrl);
}
void UpdateJobRequest::setCalendar(const std::string& calendar)
{
calendar_ = calendar;
setBodyParameter("Calendar", calendar);
std::string UpdateJobRequest::getCalendar() const {
return calendar_;
}
bool UpdateJobRequest::getFailEnable()const
{
return failEnable_;
void UpdateJobRequest::setCalendar(const std::string &calendar) {
calendar_ = calendar;
setBodyParameter(std::string("Calendar"), calendar);
}
void UpdateJobRequest::setFailEnable(bool failEnable)
{
failEnable_ = failEnable;
setBodyParameter("FailEnable", failEnable ? "true" : "false");
bool UpdateJobRequest::getFailEnable() const {
return failEnable_;
}
std::string UpdateJobRequest::getSendChannel()const
{
return sendChannel_;
void UpdateJobRequest::setFailEnable(bool failEnable) {
failEnable_ = failEnable;
setBodyParameter(std::string("FailEnable"), failEnable ? "true" : "false");
}
void UpdateJobRequest::setSendChannel(const std::string& sendChannel)
{
sendChannel_ = sendChannel;
setBodyParameter("SendChannel", sendChannel);
std::string UpdateJobRequest::getSendChannel() const {
return sendChannel_;
}
int UpdateJobRequest::getDataOffset()const
{
return dataOffset_;
void UpdateJobRequest::setSendChannel(const std::string &sendChannel) {
sendChannel_ = sendChannel;
setBodyParameter(std::string("SendChannel"), sendChannel);
}
void UpdateJobRequest::setDataOffset(int dataOffset)
{
dataOffset_ = dataOffset;
setBodyParameter("DataOffset", std::to_string(dataOffset));
int UpdateJobRequest::getDataOffset() const {
return dataOffset_;
}
std::string UpdateJobRequest::getGroupId()const
{
return groupId_;
void UpdateJobRequest::setDataOffset(int dataOffset) {
dataOffset_ = dataOffset;
setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset));
}
void UpdateJobRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setBodyParameter("GroupId", groupId);
std::string UpdateJobRequest::getGroupId() const {
return groupId_;
}
int UpdateJobRequest::getTaskMaxAttempt()const
{
return taskMaxAttempt_;
void UpdateJobRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setBodyParameter(std::string("GroupId"), groupId);
}
void UpdateJobRequest::setTaskMaxAttempt(int taskMaxAttempt)
{
taskMaxAttempt_ = taskMaxAttempt;
setBodyParameter("TaskMaxAttempt", std::to_string(taskMaxAttempt));
int UpdateJobRequest::getTaskMaxAttempt() const {
return taskMaxAttempt_;
}
int UpdateJobRequest::getMaxAttempt()const
{
return maxAttempt_;
void UpdateJobRequest::setTaskMaxAttempt(int taskMaxAttempt) {
taskMaxAttempt_ = taskMaxAttempt;
setBodyParameter(std::string("TaskMaxAttempt"), std::to_string(taskMaxAttempt));
}
void UpdateJobRequest::setMaxAttempt(int maxAttempt)
{
maxAttempt_ = maxAttempt;
setBodyParameter("MaxAttempt", std::to_string(maxAttempt));
int UpdateJobRequest::getMaxAttempt() const {
return maxAttempt_;
}
int UpdateJobRequest::getDispatcherSize()const
{
return dispatcherSize_;
void UpdateJobRequest::setMaxAttempt(int maxAttempt) {
maxAttempt_ = maxAttempt;
setBodyParameter(std::string("MaxAttempt"), std::to_string(maxAttempt));
}
void UpdateJobRequest::setDispatcherSize(int dispatcherSize)
{
dispatcherSize_ = dispatcherSize;
setBodyParameter("DispatcherSize", std::to_string(dispatcherSize));
int UpdateJobRequest::getDispatcherSize() const {
return dispatcherSize_;
}
int UpdateJobRequest::getTaskAttemptInterval()const
{
return taskAttemptInterval_;
void UpdateJobRequest::setDispatcherSize(int dispatcherSize) {
dispatcherSize_ = dispatcherSize;
setBodyParameter(std::string("DispatcherSize"), std::to_string(dispatcherSize));
}
void UpdateJobRequest::setTaskAttemptInterval(int taskAttemptInterval)
{
taskAttemptInterval_ = taskAttemptInterval;
setBodyParameter("TaskAttemptInterval", std::to_string(taskAttemptInterval));
int UpdateJobRequest::getTaskAttemptInterval() const {
return taskAttemptInterval_;
}
std::string UpdateJobRequest::getExecuteMode()const
{
return executeMode_;
void UpdateJobRequest::setTaskAttemptInterval(int taskAttemptInterval) {
taskAttemptInterval_ = taskAttemptInterval;
setBodyParameter(std::string("TaskAttemptInterval"), std::to_string(taskAttemptInterval));
}
void UpdateJobRequest::setExecuteMode(const std::string& executeMode)
{
executeMode_ = executeMode;
setBodyParameter("ExecuteMode", executeMode);
std::string UpdateJobRequest::getExecuteMode() const {
return executeMode_;
}
int UpdateJobRequest::getQueueSize()const
{
return queueSize_;
void UpdateJobRequest::setExecuteMode(const std::string &executeMode) {
executeMode_ = executeMode;
setBodyParameter(std::string("ExecuteMode"), executeMode);
}
void UpdateJobRequest::setQueueSize(int queueSize)
{
queueSize_ = queueSize;
setBodyParameter("QueueSize", std::to_string(queueSize));
int UpdateJobRequest::getQueueSize() const {
return queueSize_;
}
std::string UpdateJobRequest::getTimeExpression()const
{
return timeExpression_;
void UpdateJobRequest::setQueueSize(int queueSize) {
queueSize_ = queueSize;
setBodyParameter(std::string("QueueSize"), std::to_string(queueSize));
}
void UpdateJobRequest::setTimeExpression(const std::string& timeExpression)
{
timeExpression_ = timeExpression;
setBodyParameter("TimeExpression", timeExpression);
std::string UpdateJobRequest::getTimeExpression() const {
return timeExpression_;
}
std::string UpdateJobRequest::getClassName()const
{
return className_;
void UpdateJobRequest::setTimeExpression(const std::string &timeExpression) {
timeExpression_ = timeExpression;
setBodyParameter(std::string("TimeExpression"), timeExpression);
}
void UpdateJobRequest::setClassName(const std::string& className)
{
className_ = className;
setBodyParameter("ClassName", className);
std::string UpdateJobRequest::getClassName() const {
return className_;
}
bool UpdateJobRequest::getTimeoutEnable()const
{
return timeoutEnable_;
void UpdateJobRequest::setClassName(const std::string &className) {
className_ = className;
setBodyParameter(std::string("ClassName"), className);
}
void UpdateJobRequest::setTimeoutEnable(bool timeoutEnable)
{
timeoutEnable_ = timeoutEnable;
setBodyParameter("TimeoutEnable", timeoutEnable ? "true" : "false");
bool UpdateJobRequest::getTimeoutEnable() const {
return timeoutEnable_;
}
std::vector<UpdateJobRequest::ContactInfo> UpdateJobRequest::getContactInfo()const
{
return contactInfo_;
void UpdateJobRequest::setTimeoutEnable(bool timeoutEnable) {
timeoutEnable_ = timeoutEnable;
setBodyParameter(std::string("TimeoutEnable"), timeoutEnable ? "true" : "false");
}
void UpdateJobRequest::setContactInfo(const std::vector<ContactInfo>& contactInfo)
{
contactInfo_ = contactInfo;
for(int dep1 = 0; dep1!= contactInfo.size(); dep1++) {
auto contactInfoObj = contactInfo.at(dep1);
std::string contactInfoObjStr = "ContactInfo." + std::to_string(dep1 + 1);
setParameter(contactInfoObjStr + ".UserPhone", contactInfoObj.userPhone);
setParameter(contactInfoObjStr + ".UserName", contactInfoObj.userName);
}
std::vector<UpdateJobRequest::ContactInfo> UpdateJobRequest::getContactInfo() const {
return contactInfo_;
}
std::string UpdateJobRequest::getName()const
{
return name_;
void UpdateJobRequest::setContactInfo(const std::vector<UpdateJobRequest::ContactInfo> &contactInfo) {
contactInfo_ = contactInfo;
for(int dep1 = 0; dep1 != contactInfo.size(); dep1++) {
auto contactInfoObj = contactInfo.at(dep1);
std::string contactInfoObjStr = std::string("ContactInfo") + "." + std::to_string(dep1 + 1);
setBodyParameter(contactInfoObjStr + ".UserPhone", contactInfoObj.userPhone);
setBodyParameter(contactInfoObjStr + ".UserName", contactInfoObj.userName);
}
}
void UpdateJobRequest::setName(const std::string& name)
{
name_ = name;
setBodyParameter("Name", name);
std::string UpdateJobRequest::getName() const {
return name_;
}
std::string UpdateJobRequest::get_Namespace()const
{
return _namespace_;
void UpdateJobRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
void UpdateJobRequest::set_Namespace(const std::string& _namespace)
{
_namespace_ = _namespace;
setBodyParameter("_Namespace", _namespace);
std::string UpdateJobRequest::get_Namespace() const {
return _namespace_;
}
int UpdateJobRequest::getMaxConcurrency()const
{
return maxConcurrency_;
void UpdateJobRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setBodyParameter(std::string("Namespace"), _namespace);
}
void UpdateJobRequest::setMaxConcurrency(int maxConcurrency)
{
maxConcurrency_ = maxConcurrency;
setBodyParameter("MaxConcurrency", std::to_string(maxConcurrency));
int UpdateJobRequest::getMaxConcurrency() const {
return maxConcurrency_;
}
int UpdateJobRequest::getTimeType()const
{
return timeType_;
void UpdateJobRequest::setMaxConcurrency(int maxConcurrency) {
maxConcurrency_ = maxConcurrency;
setBodyParameter(std::string("MaxConcurrency"), std::to_string(maxConcurrency));
}
void UpdateJobRequest::setTimeType(int timeType)
{
timeType_ = timeType;
setBodyParameter("TimeType", std::to_string(timeType));
int UpdateJobRequest::getTimeType() const {
return timeType_;
}
std::string UpdateJobRequest::getParameters()const
{
return parameters_;
void UpdateJobRequest::setTimeType(int timeType) {
timeType_ = timeType;
setBodyParameter(std::string("TimeType"), std::to_string(timeType));
}
void UpdateJobRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setBodyParameter("Parameters", parameters);
std::string UpdateJobRequest::getParameters() const {
return parameters_;
}
void UpdateJobRequest::setParameters(const std::string &parameters) {
parameters_ = parameters;
setBodyParameter(std::string("Parameters"), parameters);
}

4
schedulerx2/src/model/UpdateJobResult.cc
View File

@@ -41,10 +41,10 @@ void UpdateJobResult::parse(const std::string &payload)
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();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}