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

Lingjun Controller Initial Version Released.

Browse Source
This commit is contained in:
sdk-team
2023-02-21 05:36:39 +00:00
parent 53da02f63b
commit cbcd585696
77 changed files with 5514 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
eflo-controller/include/alibabacloud/eflo-controller/Eflo_controllerClient.h Normal file
View File

@@ -0,0 +1,190 @@
/*
* 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_EFLO_CONTROLLER_EFLO_CONTROLLERCLIENT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_EFLO_CONTROLLERCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "Eflo_controllerExport.h"
#include "model/ChangeResourceGroupRequest.h"
#include "model/ChangeResourceGroupResult.h"
#include "model/CreateClusterRequest.h"
#include "model/CreateClusterResult.h"
#include "model/DeleteClusterRequest.h"
#include "model/DeleteClusterResult.h"
#include "model/DescribeClusterRequest.h"
#include "model/DescribeClusterResult.h"
#include "model/DescribeNodeRequest.h"
#include "model/DescribeNodeResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeTaskRequest.h"
#include "model/DescribeTaskResult.h"
#include "model/DescribeZonesRequest.h"
#include "model/DescribeZonesResult.h"
#include "model/ExtendClusterRequest.h"
#include "model/ExtendClusterResult.h"
#include "model/ListClusterNodesRequest.h"
#include "model/ListClusterNodesResult.h"
#include "model/ListClustersRequest.h"
#include "model/ListClustersResult.h"
#include "model/ListFreeNodesRequest.h"
#include "model/ListFreeNodesResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/RebootNodesRequest.h"
#include "model/RebootNodesResult.h"
#include "model/ReimageNodesRequest.h"
#include "model/ReimageNodesResult.h"
#include "model/ShrinkClusterRequest.h"
#include "model/ShrinkClusterResult.h"
#include "model/TagResourcesRequest.h"
#include "model/TagResourcesResult.h"
#include "model/UntagResourcesRequest.h"
#include "model/UntagResourcesResult.h"
namespace AlibabaCloud
{
namespace Eflo_controller
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT Eflo_controllerClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::ChangeResourceGroupResult> ChangeResourceGroupOutcome;
typedef std::future<ChangeResourceGroupOutcome> ChangeResourceGroupOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::ChangeResourceGroupRequest&, const ChangeResourceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeResourceGroupAsyncHandler;
typedef Outcome<Error, Model::CreateClusterResult> CreateClusterOutcome;
typedef std::future<CreateClusterOutcome> CreateClusterOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::CreateClusterRequest&, const CreateClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateClusterAsyncHandler;
typedef Outcome<Error, Model::DeleteClusterResult> DeleteClusterOutcome;
typedef std::future<DeleteClusterOutcome> DeleteClusterOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::DeleteClusterRequest&, const DeleteClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteClusterAsyncHandler;
typedef Outcome<Error, Model::DescribeClusterResult> DescribeClusterOutcome;
typedef std::future<DescribeClusterOutcome> DescribeClusterOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::DescribeClusterRequest&, const DescribeClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClusterAsyncHandler;
typedef Outcome<Error, Model::DescribeNodeResult> DescribeNodeOutcome;
typedef std::future<DescribeNodeOutcome> DescribeNodeOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::DescribeNodeRequest&, const DescribeNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNodeAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeTaskResult> DescribeTaskOutcome;
typedef std::future<DescribeTaskOutcome> DescribeTaskOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::DescribeTaskRequest&, const DescribeTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTaskAsyncHandler;
typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
typedef Outcome<Error, Model::ExtendClusterResult> ExtendClusterOutcome;
typedef std::future<ExtendClusterOutcome> ExtendClusterOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::ExtendClusterRequest&, const ExtendClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtendClusterAsyncHandler;
typedef Outcome<Error, Model::ListClusterNodesResult> ListClusterNodesOutcome;
typedef std::future<ListClusterNodesOutcome> ListClusterNodesOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::ListClusterNodesRequest&, const ListClusterNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterNodesAsyncHandler;
typedef Outcome<Error, Model::ListClustersResult> ListClustersOutcome;
typedef std::future<ListClustersOutcome> ListClustersOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::ListClustersRequest&, const ListClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClustersAsyncHandler;
typedef Outcome<Error, Model::ListFreeNodesResult> ListFreeNodesOutcome;
typedef std::future<ListFreeNodesOutcome> ListFreeNodesOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::ListFreeNodesRequest&, const ListFreeNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFreeNodesAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
typedef Outcome<Error, Model::RebootNodesResult> RebootNodesOutcome;
typedef std::future<RebootNodesOutcome> RebootNodesOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::RebootNodesRequest&, const RebootNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RebootNodesAsyncHandler;
typedef Outcome<Error, Model::ReimageNodesResult> ReimageNodesOutcome;
typedef std::future<ReimageNodesOutcome> ReimageNodesOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::ReimageNodesRequest&, const ReimageNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReimageNodesAsyncHandler;
typedef Outcome<Error, Model::ShrinkClusterResult> ShrinkClusterOutcome;
typedef std::future<ShrinkClusterOutcome> ShrinkClusterOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::ShrinkClusterRequest&, const ShrinkClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ShrinkClusterAsyncHandler;
typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
typedef std::function<void(const Eflo_controllerClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
Eflo_controllerClient(const Credentials &credentials, const ClientConfiguration &configuration);
Eflo_controllerClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
Eflo_controllerClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~Eflo_controllerClient();
ChangeResourceGroupOutcome changeResourceGroup(const Model::ChangeResourceGroupRequest &request)const;
void changeResourceGroupAsync(const Model::ChangeResourceGroupRequest& request, const ChangeResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ChangeResourceGroupOutcomeCallable changeResourceGroupCallable(const Model::ChangeResourceGroupRequest& request) const;
CreateClusterOutcome createCluster(const Model::CreateClusterRequest &request)const;
void createClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateClusterOutcomeCallable createClusterCallable(const Model::CreateClusterRequest& request) const;
DeleteClusterOutcome deleteCluster(const Model::DeleteClusterRequest &request)const;
void deleteClusterAsync(const Model::DeleteClusterRequest& request, const DeleteClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteClusterOutcomeCallable deleteClusterCallable(const Model::DeleteClusterRequest& request) const;
DescribeClusterOutcome describeCluster(const Model::DescribeClusterRequest &request)const;
void describeClusterAsync(const Model::DescribeClusterRequest& request, const DescribeClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeClusterOutcomeCallable describeClusterCallable(const Model::DescribeClusterRequest& request) const;
DescribeNodeOutcome describeNode(const Model::DescribeNodeRequest &request)const;
void describeNodeAsync(const Model::DescribeNodeRequest& request, const DescribeNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeNodeOutcomeCallable describeNodeCallable(const Model::DescribeNodeRequest& request) const;
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;
DescribeTaskOutcome describeTask(const Model::DescribeTaskRequest &request)const;
void describeTaskAsync(const Model::DescribeTaskRequest& request, const DescribeTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTaskOutcomeCallable describeTaskCallable(const Model::DescribeTaskRequest& request) const;
DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
ExtendClusterOutcome extendCluster(const Model::ExtendClusterRequest &request)const;
void extendClusterAsync(const Model::ExtendClusterRequest& request, const ExtendClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtendClusterOutcomeCallable extendClusterCallable(const Model::ExtendClusterRequest& request) const;
ListClusterNodesOutcome listClusterNodes(const Model::ListClusterNodesRequest &request)const;
void listClusterNodesAsync(const Model::ListClusterNodesRequest& request, const ListClusterNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListClusterNodesOutcomeCallable listClusterNodesCallable(const Model::ListClusterNodesRequest& request) const;
ListClustersOutcome listClusters(const Model::ListClustersRequest &request)const;
void listClustersAsync(const Model::ListClustersRequest& request, const ListClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListClustersOutcomeCallable listClustersCallable(const Model::ListClustersRequest& request) const;
ListFreeNodesOutcome listFreeNodes(const Model::ListFreeNodesRequest &request)const;
void listFreeNodesAsync(const Model::ListFreeNodesRequest& request, const ListFreeNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListFreeNodesOutcomeCallable listFreeNodesCallable(const Model::ListFreeNodesRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
RebootNodesOutcome rebootNodes(const Model::RebootNodesRequest &request)const;
void rebootNodesAsync(const Model::RebootNodesRequest& request, const RebootNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RebootNodesOutcomeCallable rebootNodesCallable(const Model::RebootNodesRequest& request) const;
ReimageNodesOutcome reimageNodes(const Model::ReimageNodesRequest &request)const;
void reimageNodesAsync(const Model::ReimageNodesRequest& request, const ReimageNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReimageNodesOutcomeCallable reimageNodesCallable(const Model::ReimageNodesRequest& request) const;
ShrinkClusterOutcome shrinkCluster(const Model::ShrinkClusterRequest &request)const;
void shrinkClusterAsync(const Model::ShrinkClusterRequest& request, const ShrinkClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ShrinkClusterOutcomeCallable shrinkClusterCallable(const Model::ShrinkClusterRequest& request) const;
TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_EFLO_CONTROLLERCLIENT_H_

32
eflo-controller/include/alibabacloud/eflo-controller/Eflo_controllerExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* 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_EFLO_CONTROLLER_EFLO_CONTROLLEREXPORT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_EFLO_CONTROLLEREXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_EFLO_CONTROLLER_LIBRARY)
# define ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_EFLO_CONTROLLER_EXPORT
#endif
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_EFLO_CONTROLLEREXPORT_H_

54
eflo-controller/include/alibabacloud/eflo-controller/model/ChangeResourceGroupRequest.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_EFLO_CONTROLLER_MODEL_CHANGERESOURCEGROUPREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CHANGERESOURCEGROUPREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ChangeResourceGroupRequest : public RpcServiceRequest {
public:
ChangeResourceGroupRequest();
~ChangeResourceGroupRequest();
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getResourceRegionId() const;
void setResourceRegionId(const std::string &resourceRegionId);
std::string getResourceId() const;
void setResourceId(const std::string &resourceId);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getService() const;
void setService(const std::string &service);
private:
std::string resourceGroupId_;
std::string resourceRegionId_;
std::string resourceId_;
std::string resourceType_;
std::string service_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CHANGERESOURCEGROUPREQUEST_H_

49
eflo-controller/include/alibabacloud/eflo-controller/model/ChangeResourceGroupResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CHANGERESOURCEGROUPRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CHANGERESOURCEGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ChangeResourceGroupResult : public ServiceResult
{
public:
ChangeResourceGroupResult();
explicit ChangeResourceGroupResult(const std::string &payload);
~ChangeResourceGroupResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CHANGERESOURCEGROUPRESULT_H_

111
eflo-controller/include/alibabacloud/eflo-controller/model/CreateClusterRequest.h Normal file
View File

@@ -0,0 +1,111 @@
/*
* 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_EFLO_CONTROLLER_MODEL_CREATECLUSTERREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CREATECLUSTERREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT CreateClusterRequest : public RpcServiceRequest {
public:
struct Components {
std::string componentType;
struct ComponentConfig {
ObjectOfAny basicArgs;
ObjectOfAny objectOfAny;
std::vector<ObjectOfAny> nodeUnits;
};
ComponentConfig componentConfig;
};
struct Networks {
struct NewVpdInfo {
std::string monitorVswitchId;
struct VpdSubnetsItem {
std::string subnetType;
std::string zoneId;
std::string subnetCidr;
};
VpdSubnetsItem vpdSubnetsItem;
std::vector<VpdSubnetsItem> vpdSubnets;
std::string cloudLinkId;
std::string vpdCidr;
std::string cloudLinkCidr;
std::string cenId;
std::string monitorVpcId;
};
NewVpdInfo newVpdInfo;
};
struct NodeGroups {
std::string nodeGroupName;
struct NodesItem {
std::string hostname;
std::string loginPassword;
std::string nodeId;
};
NodesItem nodesItem;
std::vector<NodesItem> nodes;
std::string imageId;
std::string nodeGroupDescription;
std::string zoneId;
std::string machineType;
};
struct Tag {
std::string value;
std::string key;
};
CreateClusterRequest();
~CreateClusterRequest();
std::vector<Components> getComponents() const;
void setComponents(const std::vector<Components> &components);
std::string getClusterName() const;
void setClusterName(const std::string &clusterName);
Networks getNetworks() const;
void setNetworks(const Networks &networks);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getClusterDescription() const;
void setClusterDescription(const std::string &clusterDescription);
std::vector<NodeGroups> getNodeGroups() const;
void setNodeGroups(const std::vector<NodeGroups> &nodeGroups);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
bool getIgnoreFailedNodeTasks() const;
void setIgnoreFailedNodeTasks(bool ignoreFailedNodeTasks);
std::string getClusterType() const;
void setClusterType(const std::string &clusterType);
private:
std::vector<Components> components_;
std::string clusterName_;
Networks networks_;
std::string resourceGroupId_;
std::string clusterDescription_;
std::vector<NodeGroups> nodeGroups_;
std::vector<Tag> tag_;
bool ignoreFailedNodeTasks_;
std::string clusterType_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CREATECLUSTERREQUEST_H_

53
eflo-controller/include/alibabacloud/eflo-controller/model/CreateClusterResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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_EFLO_CONTROLLER_MODEL_CREATECLUSTERRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CREATECLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT CreateClusterResult : public ServiceResult
{
public:
CreateClusterResult();
explicit CreateClusterResult(const std::string &payload);
~CreateClusterResult();
std::string getTaskId()const;
std::string getClusterId()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string clusterId_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_CREATECLUSTERRESULT_H_

42
eflo-controller/include/alibabacloud/eflo-controller/model/DeleteClusterRequest.h Normal file
View File

@@ -0,0 +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_EFLO_CONTROLLER_MODEL_DELETECLUSTERREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DELETECLUSTERREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DeleteClusterRequest : public RpcServiceRequest {
public:
DeleteClusterRequest();
~DeleteClusterRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
private:
std::string clusterId_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DELETECLUSTERREQUEST_H_

49
eflo-controller/include/alibabacloud/eflo-controller/model/DeleteClusterResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DELETECLUSTERRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DELETECLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DeleteClusterResult : public ServiceResult
{
public:
DeleteClusterResult();
explicit DeleteClusterResult(const std::string &payload);
~DeleteClusterResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DELETECLUSTERRESULT_H_

42
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeClusterRequest.h Normal file
View File

@@ -0,0 +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_EFLO_CONTROLLER_MODEL_DESCRIBECLUSTERREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBECLUSTERREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeClusterRequest : public RpcServiceRequest {
public:
DescribeClusterRequest();
~DescribeClusterRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
private:
std::string clusterId_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBECLUSTERREQUEST_H_

84
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeClusterResult.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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_EFLO_CONTROLLER_MODEL_DESCRIBECLUSTERRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBECLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeClusterResult : public ServiceResult
{
public:
struct ComponentsItem
{
std::string componentType;
std::string componentId;
};
struct NetworksItem
{
std::string vpdId;
};
DescribeClusterResult();
explicit DescribeClusterResult(const std::string &payload);
~DescribeClusterResult();
std::vector<NetworksItem> getNetworks()const;
std::string getTaskId()const;
long getNodeCount()const;
std::string getResourceGroupId()const;
std::string getClusterId()const;
std::string getCreateTime()const;
long getNodeGroupCount()const;
std::string getOperatingState()const;
std::string getClusterType()const;
std::vector<ComponentsItem> getComponents()const;
std::string getUpdateTime()const;
std::string getClusterName()const;
std::string getClusterDescription()const;
protected:
void parse(const std::string &payload);
private:
std::vector<NetworksItem> networks_;
std::string taskId_;
long nodeCount_;
std::string resourceGroupId_;
std::string clusterId_;
std::string createTime_;
long nodeGroupCount_;
std::string operatingState_;
std::string clusterType_;
std::vector<ComponentsItem> components_;
std::string updateTime_;
std::string clusterName_;
std::string clusterDescription_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBECLUSTERRESULT_H_

42
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeNodeRequest.h Normal file
View File

@@ -0,0 +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_EFLO_CONTROLLER_MODEL_DESCRIBENODEREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBENODEREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeNodeRequest : public RpcServiceRequest {
public:
DescribeNodeRequest();
~DescribeNodeRequest();
std::string getNodeId() const;
void setNodeId(const std::string &nodeId);
private:
std::string nodeId_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBENODEREQUEST_H_

84
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeNodeResult.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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_EFLO_CONTROLLER_MODEL_DESCRIBENODERESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBENODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeNodeResult : public ServiceResult
{
public:
struct NetworksItem
{
std::string bondName;
std::string vpdId;
std::string ip;
std::string subnetId;
};
DescribeNodeResult();
explicit DescribeNodeResult(const std::string &payload);
~DescribeNodeResult();
std::vector<NetworksItem> getNetworks()const;
std::string getNodeGroupName()const;
std::string getZoneId()const;
std::string getClusterId()const;
std::string getCreateTime()const;
std::string getHostname()const;
std::string getMachineType()const;
std::string getOperatingState()const;
std::string getNodeGroupId()const;
std::string getExpiredTime()const;
std::string getImageId()const;
std::string getNodeId()const;
std::string getClusterName()const;
std::string getSn()const;
protected:
void parse(const std::string &payload);
private:
std::vector<NetworksItem> networks_;
std::string nodeGroupName_;
std::string zoneId_;
std::string clusterId_;
std::string createTime_;
std::string hostname_;
std::string machineType_;
std::string operatingState_;
std::string nodeGroupId_;
std::string expiredTime_;
std::string imageId_;
std::string nodeId_;
std::string clusterName_;
std::string sn_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBENODERESULT_H_

42
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeRegionsRequest.h Normal file
View File

@@ -0,0 +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_EFLO_CONTROLLER_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeRegionsRequest : public RpcServiceRequest {
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEREGIONSREQUEST_H_

56
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeRegionsResult.h Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct RegionsItem
{
std::string regionId;
std::string localName;
};
DescribeRegionsResult();
explicit DescribeRegionsResult(const std::string &payload);
~DescribeRegionsResult();
std::vector<RegionsItem> getRegions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<RegionsItem> regions_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEREGIONSRESULT_H_

42
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeTaskRequest.h Normal file
View File

@@ -0,0 +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_EFLO_CONTROLLER_MODEL_DESCRIBETASKREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBETASKREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeTaskRequest : public RpcServiceRequest {
public:
DescribeTaskRequest();
~DescribeTaskRequest();
std::string getTaskId() const;
void setTaskId(const std::string &taskId);
private:
std::string taskId_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBETASKREQUEST_H_

85
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeTaskResult.h Normal file
View File

@@ -0,0 +1,85 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBETASKRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBETASKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeTaskResult : public ServiceResult
{
public:
struct StepsItem
{
struct SubTasksItem
{
std::string taskId;
std::string message;
std::string taskType;
std::string createTime;
std::string updateTime;
std::string taskState;
};
std::string stepState;
std::string message;
std::string stepType;
std::string startTime;
std::string updateTime;
std::string stageTag;
std::string stepName;
std::vector<StepsItem::SubTasksItem> subTasks;
};
DescribeTaskResult();
explicit DescribeTaskResult(const std::string &payload);
~DescribeTaskResult();
std::vector<StepsItem> getSteps()const;
std::string getMessage()const;
std::string getClusterId()const;
std::string getTaskType()const;
std::string getCreateTime()const;
std::string getUpdateTime()const;
std::string getClusterName()const;
std::string getTaskState()const;
protected:
void parse(const std::string &payload);
private:
std::vector<StepsItem> steps_;
std::string message_;
std::string clusterId_;
std::string taskType_;
std::string createTime_;
std::string updateTime_;
std::string clusterName_;
std::string taskState_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBETASKRESULT_H_

42
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeZonesRequest.h Normal file
View File

@@ -0,0 +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_EFLO_CONTROLLER_MODEL_DESCRIBEZONESREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEZONESREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeZonesRequest : public RpcServiceRequest {
public:
DescribeZonesRequest();
~DescribeZonesRequest();
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEZONESREQUEST_H_

56
eflo-controller/include/alibabacloud/eflo-controller/model/DescribeZonesResult.h Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEZONESRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEZONESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT DescribeZonesResult : public ServiceResult
{
public:
struct ZonesItem
{
std::string zoneId;
std::string localName;
};
DescribeZonesResult();
explicit DescribeZonesResult(const std::string &payload);
~DescribeZonesResult();
std::vector<ZonesItem> getZones()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ZonesItem> zones_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_DESCRIBEZONESRESULT_H_

58
eflo-controller/include/alibabacloud/eflo-controller/model/ExtendClusterRequest.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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_EFLO_CONTROLLER_MODEL_EXTENDCLUSTERREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_EXTENDCLUSTERREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ExtendClusterRequest : public RpcServiceRequest {
public:
struct NodeGroups {
struct NodesItem {
std::string hostname;
std::string loginPassword;
std::string nodeId;
};
NodesItem nodesItem;
std::vector<NodesItem> nodes;
std::string nodeGroupId;
};
ExtendClusterRequest();
~ExtendClusterRequest();
bool getIgnoreFailedNodeTasks() const;
void setIgnoreFailedNodeTasks(bool ignoreFailedNodeTasks);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::vector<NodeGroups> getNodeGroups() const;
void setNodeGroups(const std::vector<NodeGroups> &nodeGroups);
private:
bool ignoreFailedNodeTasks_;
std::string clusterId_;
std::vector<NodeGroups> nodeGroups_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_EXTENDCLUSTERREQUEST_H_

51
eflo-controller/include/alibabacloud/eflo-controller/model/ExtendClusterResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_EXTENDCLUSTERRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_EXTENDCLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ExtendClusterResult : public ServiceResult
{
public:
ExtendClusterResult();
explicit ExtendClusterResult(const std::string &payload);
~ExtendClusterResult();
std::string getTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_EXTENDCLUSTERRESULT_H_

51
eflo-controller/include/alibabacloud/eflo-controller/model/ListClusterNodesRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERNODESREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERNODESREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ListClusterNodesRequest : public RpcServiceRequest {
public:
ListClusterNodesRequest();
~ListClusterNodesRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string getNodeGroupId() const;
void setNodeGroupId(const std::string &nodeGroupId);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
long getMaxResults() const;
void setMaxResults(long maxResults);
private:
std::string clusterId_;
std::string nodeGroupId_;
std::string nextToken_;
long maxResults_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERNODESREQUEST_H_

75
eflo-controller/include/alibabacloud/eflo-controller/model/ListClusterNodesResult.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERNODESRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERNODESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ListClusterNodesResult : public ServiceResult
{
public:
struct NodesItem
{
struct NetworksItem
{
std::string bondName;
std::string vpdId;
std::string ip;
std::string subnetId;
};
std::vector<NodesItem::NetworksItem> networks;
std::string nodeGroupName;
std::string zoneId;
std::string nodeGroupId;
std::string createTime;
std::string expiredTime;
std::string hostname;
std::string imageId;
std::string machineType;
std::string nodeId;
std::string operatingState;
std::string sn;
};
ListClusterNodesResult();
explicit ListClusterNodesResult(const std::string &payload);
~ListClusterNodesResult();
std::string getNextToken()const;
std::vector<NodesItem> getNodes()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<NodesItem> nodes_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERNODESRESULT_H_

48
eflo-controller/include/alibabacloud/eflo-controller/model/ListClustersRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERSREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERSREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ListClustersRequest : public RpcServiceRequest {
public:
ListClustersRequest();
~ListClustersRequest();
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
long getMaxResults() const;
void setMaxResults(long maxResults);
private:
std::string resourceGroupId_;
std::string nextToken_;
long maxResults_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERSREQUEST_H_

68
eflo-controller/include/alibabacloud/eflo-controller/model/ListClustersResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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_EFLO_CONTROLLER_MODEL_LISTCLUSTERSRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ListClustersResult : public ServiceResult
{
public:
struct ClustersItem
{
ObjectOfAny components;
std::string taskId;
long nodeCount;
std::string resourceGroupId;
std::string clusterId;
std::string createTime;
std::string updateTime;
std::string clusterName;
long nodeGroupCount;
std::string operatingState;
std::string clusterType;
std::string clusterDescription;
};
ListClustersResult();
explicit ListClustersResult(const std::string &payload);
~ListClustersResult();
std::string getNextToken()const;
std::vector<ClustersItem> getClusters()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<ClustersItem> clusters_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTCLUSTERSRESULT_H_

48
eflo-controller/include/alibabacloud/eflo-controller/model/ListFreeNodesRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTFREENODESREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTFREENODESREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ListFreeNodesRequest : public RpcServiceRequest {
public:
ListFreeNodesRequest();
~ListFreeNodesRequest();
std::string getMachineType() const;
void setMachineType(const std::string &machineType);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
long getMaxResults() const;
void setMaxResults(long maxResults);
private:
std::string machineType_;
std::string nextToken_;
long maxResults_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTFREENODESREQUEST_H_

62
eflo-controller/include/alibabacloud/eflo-controller/model/ListFreeNodesResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* 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_EFLO_CONTROLLER_MODEL_LISTFREENODESRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTFREENODESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ListFreeNodesResult : public ServiceResult
{
public:
struct NodesItem
{
std::string zoneId;
std::string createTime;
std::string expiredTime;
std::string nodeId;
std::string machineType;
std::string sn;
};
ListFreeNodesResult();
explicit ListFreeNodesResult(const std::string &payload);
~ListFreeNodesResult();
std::string getNextToken()const;
std::vector<NodesItem> getNodes()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<NodesItem> nodes_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTFREENODESRESULT_H_

61
eflo-controller/include/alibabacloud/eflo-controller/model/ListTagResourcesRequest.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTTAGRESOURCESREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ListTagResourcesRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
ListTagResourcesRequest();
~ListTagResourcesRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::vector<std::string> getResourceId() const;
void setResourceId(const std::vector<std::string> &resourceId);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getService() const;
void setService(const std::string &service);
private:
std::string regionId_;
std::string nextToken_;
std::vector<Tag> tag_;
std::vector<std::string> resourceId_;
std::string resourceType_;
std::string service_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTTAGRESOURCESREQUEST_H_

60
eflo-controller/include/alibabacloud/eflo-controller/model/ListTagResourcesResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ListTagResourcesResult : public ServiceResult
{
public:
struct TagResource
{
std::string resourceId;
std::string tagKey;
std::string resourceType;
std::string tagValue;
};
ListTagResourcesResult();
explicit ListTagResourcesResult(const std::string &payload);
~ListTagResourcesResult();
std::string getNextToken()const;
std::vector<TagResource> getTagResources()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<TagResource> tagResources_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_LISTTAGRESOURCESRESULT_H_

48
eflo-controller/include/alibabacloud/eflo-controller/model/RebootNodesRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REBOOTNODESREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REBOOTNODESREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT RebootNodesRequest : public RpcServiceRequest {
public:
RebootNodesRequest();
~RebootNodesRequest();
bool getIgnoreFailedNodeTasks() const;
void setIgnoreFailedNodeTasks(bool ignoreFailedNodeTasks);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::vector<std::string> getNodes() const;
void setNodes(const std::vector<std::string> &nodes);
private:
bool ignoreFailedNodeTasks_;
std::string clusterId_;
std::vector<std::string> nodes_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REBOOTNODESREQUEST_H_

51
eflo-controller/include/alibabacloud/eflo-controller/model/RebootNodesResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REBOOTNODESRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REBOOTNODESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT RebootNodesResult : public ServiceResult
{
public:
RebootNodesResult();
explicit RebootNodesResult(const std::string &payload);
~RebootNodesResult();
std::string getTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REBOOTNODESRESULT_H_

54
eflo-controller/include/alibabacloud/eflo-controller/model/ReimageNodesRequest.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_EFLO_CONTROLLER_MODEL_REIMAGENODESREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REIMAGENODESREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ReimageNodesRequest : public RpcServiceRequest {
public:
struct Nodes {
std::string hostname;
std::string imageId;
std::string loginPassword;
std::string nodeId;
};
ReimageNodesRequest();
~ReimageNodesRequest();
bool getIgnoreFailedNodeTasks() const;
void setIgnoreFailedNodeTasks(bool ignoreFailedNodeTasks);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::vector<Nodes> getNodes() const;
void setNodes(const std::vector<Nodes> &nodes);
private:
bool ignoreFailedNodeTasks_;
std::string clusterId_;
std::vector<Nodes> nodes_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REIMAGENODESREQUEST_H_

51
eflo-controller/include/alibabacloud/eflo-controller/model/ReimageNodesResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REIMAGENODESRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REIMAGENODESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ReimageNodesResult : public ServiceResult
{
public:
ReimageNodesResult();
explicit ReimageNodesResult(const std::string &payload);
~ReimageNodesResult();
std::string getTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_REIMAGENODESRESULT_H_

56
eflo-controller/include/alibabacloud/eflo-controller/model/ShrinkClusterRequest.h Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_SHRINKCLUSTERREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_SHRINKCLUSTERREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ShrinkClusterRequest : public RpcServiceRequest {
public:
struct NodeGroups {
struct NodesItem {
std::string nodeId;
};
NodesItem nodesItem;
std::vector<NodesItem> nodes;
std::string nodeGroupId;
};
ShrinkClusterRequest();
~ShrinkClusterRequest();
bool getIgnoreFailedNodeTasks() const;
void setIgnoreFailedNodeTasks(bool ignoreFailedNodeTasks);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::vector<NodeGroups> getNodeGroups() const;
void setNodeGroups(const std::vector<NodeGroups> &nodeGroups);
private:
bool ignoreFailedNodeTasks_;
std::string clusterId_;
std::vector<NodeGroups> nodeGroups_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_SHRINKCLUSTERREQUEST_H_

51
eflo-controller/include/alibabacloud/eflo-controller/model/ShrinkClusterResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_SHRINKCLUSTERRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_SHRINKCLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT ShrinkClusterResult : public ServiceResult
{
public:
ShrinkClusterResult();
explicit ShrinkClusterResult(const std::string &payload);
~ShrinkClusterResult();
std::string getTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_SHRINKCLUSTERRESULT_H_

58
eflo-controller/include/alibabacloud/eflo-controller/model/TagResourcesRequest.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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_EFLO_CONTROLLER_MODEL_TAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_TAGRESOURCESREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT TagResourcesRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
TagResourcesRequest();
~TagResourcesRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::vector<std::string> getResourceId() const;
void setResourceId(const std::vector<std::string> &resourceId);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getService() const;
void setService(const std::string &service);
private:
std::string regionId_;
std::vector<Tag> tag_;
std::vector<std::string> resourceId_;
std::string resourceType_;
std::string service_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_TAGRESOURCESREQUEST_H_

49
eflo-controller/include/alibabacloud/eflo-controller/model/TagResourcesResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_TAGRESOURCESRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_TAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT TagResourcesResult : public ServiceResult
{
public:
TagResourcesResult();
explicit TagResourcesResult(const std::string &payload);
~TagResourcesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_TAGRESOURCESRESULT_H_

57
eflo-controller/include/alibabacloud/eflo-controller/model/UntagResourcesRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_UNTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_UNTAGRESOURCESREQUEST_H_
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo_controller {
namespace Model {
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT UntagResourcesRequest : public RpcServiceRequest {
public:
UntagResourcesRequest();
~UntagResourcesRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
bool getAll() const;
void setAll(bool all);
std::vector<std::string> getResourceId() const;
void setResourceId(const std::vector<std::string> &resourceId);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getService() const;
void setService(const std::string &service);
std::vector<std::string> getTagKey() const;
void setTagKey(const std::vector<std::string> &tagKey);
private:
std::string regionId_;
bool all_;
std::vector<std::string> resourceId_;
std::string resourceType_;
std::string service_;
std::vector<std::string> tagKey_;
};
} // namespace Model
} // namespace Eflo_controller
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_UNTAGRESOURCESREQUEST_H_

49
eflo-controller/include/alibabacloud/eflo-controller/model/UntagResourcesResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_CONTROLLER_MODEL_UNTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_EFLO_CONTROLLER_MODEL_UNTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo-controller/Eflo_controllerExport.h>
namespace AlibabaCloud
{
namespace Eflo_controller
{
namespace Model
{
class ALIBABACLOUD_EFLO_CONTROLLER_EXPORT UntagResourcesResult : public ServiceResult
{
public:
UntagResourcesResult();
explicit UntagResourcesResult(const std::string &payload);
~UntagResourcesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_CONTROLLER_MODEL_UNTAGRESOURCESRESULT_H_