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

Lindorm open api.

Browse Source
This commit is contained in:
sdk-team
2023-11-22 12:11:51 +00:00
parent 1fa00fa025
commit d24791dc62
28 changed files with 1322 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
hitsdb/CMakeLists.txt
View File

@@ -21,12 +21,18 @@ set(hitsdb_public_header
include/alibabacloud/hitsdb/HitsdbExport.h )
set(hitsdb_public_header_model
include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h
include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.h
include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h
include/alibabacloud/hitsdb/model/CreateLindormInstanceResult.h
include/alibabacloud/hitsdb/model/DescribeRegionsRequest.h
include/alibabacloud/hitsdb/model/DescribeRegionsResult.h
include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListRequest.h
include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h
include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h
include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h
include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h
include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h
include/alibabacloud/hitsdb/model/GetLindormInstanceRequest.h
include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h
include/alibabacloud/hitsdb/model/GetLindormInstanceEngineListRequest.h
@@ -52,12 +58,18 @@ set(hitsdb_public_header_model
set(hitsdb_src
src/HitsdbClient.cc
src/model/CreateLdpsNamespaceRequest.cc
src/model/CreateLdpsNamespaceResult.cc
src/model/CreateLindormInstanceRequest.cc
src/model/CreateLindormInstanceResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/GetInstanceIpWhiteListRequest.cc
src/model/GetInstanceIpWhiteListResult.cc
src/model/GetLdpsNamespacedQuotaRequest.cc
src/model/GetLdpsNamespacedQuotaResult.cc
src/model/GetLdpsResourceCostRequest.cc
src/model/GetLdpsResourceCostResult.cc
src/model/GetLindormInstanceRequest.cc
src/model/GetLindormInstanceResult.cc
src/model/GetLindormInstanceEngineListRequest.cc

24
hitsdb/include/alibabacloud/hitsdb/HitsdbClient.h
View File

@@ -22,12 +22,18 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "HitsdbExport.h"
#include "model/CreateLdpsNamespaceRequest.h"
#include "model/CreateLdpsNamespaceResult.h"
#include "model/CreateLindormInstanceRequest.h"
#include "model/CreateLindormInstanceResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/GetInstanceIpWhiteListRequest.h"
#include "model/GetInstanceIpWhiteListResult.h"
#include "model/GetLdpsNamespacedQuotaRequest.h"
#include "model/GetLdpsNamespacedQuotaResult.h"
#include "model/GetLdpsResourceCostRequest.h"
#include "model/GetLdpsResourceCostResult.h"
#include "model/GetLindormInstanceRequest.h"
#include "model/GetLindormInstanceResult.h"
#include "model/GetLindormInstanceEngineListRequest.h"
@@ -59,6 +65,9 @@ namespace AlibabaCloud
class ALIBABACLOUD_HITSDB_EXPORT HitsdbClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CreateLdpsNamespaceResult> CreateLdpsNamespaceOutcome;
typedef std::future<CreateLdpsNamespaceOutcome> CreateLdpsNamespaceOutcomeCallable;
typedef std::function<void(const HitsdbClient*, const Model::CreateLdpsNamespaceRequest&, const CreateLdpsNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLdpsNamespaceAsyncHandler;
typedef Outcome<Error, Model::CreateLindormInstanceResult> CreateLindormInstanceOutcome;
typedef std::future<CreateLindormInstanceOutcome> CreateLindormInstanceOutcomeCallable;
typedef std::function<void(const HitsdbClient*, const Model::CreateLindormInstanceRequest&, const CreateLindormInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLindormInstanceAsyncHandler;
@@ -68,6 +77,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetInstanceIpWhiteListResult> GetInstanceIpWhiteListOutcome;
typedef std::future<GetInstanceIpWhiteListOutcome> GetInstanceIpWhiteListOutcomeCallable;
typedef std::function<void(const HitsdbClient*, const Model::GetInstanceIpWhiteListRequest&, const GetInstanceIpWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceIpWhiteListAsyncHandler;
typedef Outcome<Error, Model::GetLdpsNamespacedQuotaResult> GetLdpsNamespacedQuotaOutcome;
typedef std::future<GetLdpsNamespacedQuotaOutcome> GetLdpsNamespacedQuotaOutcomeCallable;
typedef std::function<void(const HitsdbClient*, const Model::GetLdpsNamespacedQuotaRequest&, const GetLdpsNamespacedQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLdpsNamespacedQuotaAsyncHandler;
typedef Outcome<Error, Model::GetLdpsResourceCostResult> GetLdpsResourceCostOutcome;
typedef std::future<GetLdpsResourceCostOutcome> GetLdpsResourceCostOutcomeCallable;
typedef std::function<void(const HitsdbClient*, const Model::GetLdpsResourceCostRequest&, const GetLdpsResourceCostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLdpsResourceCostAsyncHandler;
typedef Outcome<Error, Model::GetLindormInstanceResult> GetLindormInstanceOutcome;
typedef std::future<GetLindormInstanceOutcome> GetLindormInstanceOutcomeCallable;
typedef std::function<void(const HitsdbClient*, const Model::GetLindormInstanceRequest&, const GetLindormInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLindormInstanceAsyncHandler;
@@ -106,6 +121,9 @@ namespace AlibabaCloud
HitsdbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
HitsdbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~HitsdbClient();
CreateLdpsNamespaceOutcome createLdpsNamespace(const Model::CreateLdpsNamespaceRequest &request)const;
void createLdpsNamespaceAsync(const Model::CreateLdpsNamespaceRequest& request, const CreateLdpsNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLdpsNamespaceOutcomeCallable createLdpsNamespaceCallable(const Model::CreateLdpsNamespaceRequest& request) const;
CreateLindormInstanceOutcome createLindormInstance(const Model::CreateLindormInstanceRequest &request)const;
void createLindormInstanceAsync(const Model::CreateLindormInstanceRequest& request, const CreateLindormInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLindormInstanceOutcomeCallable createLindormInstanceCallable(const Model::CreateLindormInstanceRequest& request) const;
@@ -115,6 +133,12 @@ namespace AlibabaCloud
GetInstanceIpWhiteListOutcome getInstanceIpWhiteList(const Model::GetInstanceIpWhiteListRequest &request)const;
void getInstanceIpWhiteListAsync(const Model::GetInstanceIpWhiteListRequest& request, const GetInstanceIpWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetInstanceIpWhiteListOutcomeCallable getInstanceIpWhiteListCallable(const Model::GetInstanceIpWhiteListRequest& request) const;
GetLdpsNamespacedQuotaOutcome getLdpsNamespacedQuota(const Model::GetLdpsNamespacedQuotaRequest &request)const;
void getLdpsNamespacedQuotaAsync(const Model::GetLdpsNamespacedQuotaRequest& request, const GetLdpsNamespacedQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetLdpsNamespacedQuotaOutcomeCallable getLdpsNamespacedQuotaCallable(const Model::GetLdpsNamespacedQuotaRequest& request) const;
GetLdpsResourceCostOutcome getLdpsResourceCost(const Model::GetLdpsResourceCostRequest &request)const;
void getLdpsResourceCostAsync(const Model::GetLdpsResourceCostRequest& request, const GetLdpsResourceCostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetLdpsResourceCostOutcomeCallable getLdpsResourceCostCallable(const Model::GetLdpsResourceCostRequest& request) const;
GetLindormInstanceOutcome getLindormInstance(const Model::GetLindormInstanceRequest &request)const;
void getLindormInstanceAsync(const Model::GetLindormInstanceRequest& request, const GetLindormInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetLindormInstanceOutcomeCallable getLindormInstanceCallable(const Model::GetLindormInstanceRequest& request) const;

66
hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.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_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_
#define ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_
#include <alibabacloud/hitsdb/HitsdbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Hitsdb {
namespace Model {
class ALIBABACLOUD_HITSDB_EXPORT CreateLdpsNamespaceRequest : public RpcServiceRequest {
public:
CreateLdpsNamespaceRequest();
~CreateLdpsNamespaceRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getSecurityToken() const;
void setSecurityToken(const std::string &securityToken);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string securityToken_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string instanceId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Hitsdb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_

49
hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.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_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_
#define ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hitsdb/HitsdbExport.h>
namespace AlibabaCloud
{
namespace Hitsdb
{
namespace Model
{
class ALIBABACLOUD_HITSDB_EXPORT CreateLdpsNamespaceResult : public ServiceResult
{
public:
CreateLdpsNamespaceResult();
explicit CreateLdpsNamespaceResult(const std::string &payload);
~CreateLdpsNamespaceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_

6
hitsdb/include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h
View File

@@ -54,6 +54,8 @@ public:
void setLindormNum(int lindormNum);
std::string getVSwitchId() const;
void setVSwitchId(const std::string &vSwitchId);
int getStreamNum() const;
void setStreamNum(int streamNum);
int getLogSingleStorage() const;
void setLogSingleStorage(int logSingleStorage);
std::string getZoneId() const;
@@ -104,6 +106,8 @@ public:
void setInstanceAlias(const std::string &instanceAlias);
int getFilestoreNum() const;
void setFilestoreNum(int filestoreNum);
std::string getStreamSpec() const;
void setStreamSpec(const std::string &streamSpec);
std::string getCoreSpec() const;
void setCoreSpec(const std::string &coreSpec);
std::string getVPCId() const;
@@ -126,6 +130,7 @@ private:
long ownerId_;
int lindormNum_;
std::string vSwitchId_;
int streamNum_;
int logSingleStorage_;
std::string zoneId_;
std::string arbiterZoneId_;
@@ -151,6 +156,7 @@ private:
std::string ownerAccount_;
std::string instanceAlias_;
int filestoreNum_;
std::string streamSpec_;
std::string coreSpec_;
std::string vPCId_;
std::string payType_;

7
hitsdb/include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h
View File

@@ -32,17 +32,24 @@ namespace AlibabaCloud
class ALIBABACLOUD_HITSDB_EXPORT GetInstanceIpWhiteListResult : public ServiceResult
{
public:
struct GroupListItem
{
std::string groupName;
std::string securityIpList;
};
GetInstanceIpWhiteListResult();
explicit GetInstanceIpWhiteListResult(const std::string &payload);
~GetInstanceIpWhiteListResult();
std::vector<GroupListItem> getGroupList()const;
std::vector<std::string> getIpList()const;
std::string getInstanceId()const;
protected:
void parse(const std::string &payload);
private:
std::vector<GroupListItem> groupList_;
std::vector<std::string> ipList_;
std::string instanceId_;

66
hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.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_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_
#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_
#include <alibabacloud/hitsdb/HitsdbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Hitsdb {
namespace Model {
class ALIBABACLOUD_HITSDB_EXPORT GetLdpsNamespacedQuotaRequest : public RpcServiceRequest {
public:
GetLdpsNamespacedQuotaRequest();
~GetLdpsNamespacedQuotaRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getSecurityToken() const;
void setSecurityToken(const std::string &securityToken);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string securityToken_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string instanceId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Hitsdb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_

59
hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_
#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hitsdb/HitsdbExport.h>
namespace AlibabaCloud
{
namespace Hitsdb
{
namespace Model
{
class ALIBABACLOUD_HITSDB_EXPORT GetLdpsNamespacedQuotaResult : public ServiceResult
{
public:
struct NamespacedQuota
{
std::string usedMemory;
std::string cpuAmount;
std::string usedCpu;
std::string memoryAmount;
std::string name;
};
GetLdpsNamespacedQuotaResult();
explicit GetLdpsNamespacedQuotaResult(const std::string &payload);
~GetLdpsNamespacedQuotaResult();
std::vector<NamespacedQuota> getNamespacedQuotas()const;
protected:
void parse(const std::string &payload);
private:
std::vector<NamespacedQuota> namespacedQuotas_;
};
}
}
}
#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_

72
hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h 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.
*/
#ifndef ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_
#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_
#include <alibabacloud/hitsdb/HitsdbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Hitsdb {
namespace Model {
class ALIBABACLOUD_HITSDB_EXPORT GetLdpsResourceCostRequest : public RpcServiceRequest {
public:
GetLdpsResourceCostRequest();
~GetLdpsResourceCostRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
long getStartTime() const;
void setStartTime(long startTime);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getJobId() const;
void setJobId(const std::string &jobId);
std::string getSecurityToken() const;
void setSecurityToken(const std::string &securityToken);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getEndTime() const;
void setEndTime(long endTime);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
private:
long resourceOwnerId_;
long startTime_;
std::string accessKeyId_;
std::string jobId_;
std::string securityToken_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long endTime_;
long ownerId_;
std::string instanceId_;
};
} // namespace Model
} // namespace Hitsdb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_

59
hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_
#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hitsdb/HitsdbExport.h>
namespace AlibabaCloud
{
namespace Hitsdb
{
namespace Model
{
class ALIBABACLOUD_HITSDB_EXPORT GetLdpsResourceCostResult : public ServiceResult
{
public:
GetLdpsResourceCostResult();
explicit GetLdpsResourceCostResult(const std::string &payload);
~GetLdpsResourceCostResult();
long getEndTime()const;
std::string getInstanceId()const;
long getStartTime()const;
long getTotalResource()const;
std::string getJobId()const;
protected:
void parse(const std::string &payload);
private:
long endTime_;
std::string instanceId_;
long startTime_;
long totalResource_;
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_

12
hitsdb/include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h
View File

@@ -50,6 +50,7 @@ namespace AlibabaCloud
long getExpiredMilliseconds()const;
std::string getStandbyZoneId()const;
std::vector<Engine> getEngineList()const;
bool getEnableLTS()const;
std::string getResourceGroupId()const;
bool getEnableBDS()const;
std::string getLogDiskCategory()const;
@@ -74,13 +75,17 @@ namespace AlibabaCloud
std::string getArbiterVSwitchId()const;
std::string getVpcId()const;
bool getEnableCdc()const;
bool getEnableMLCtrl()const;
bool getEnableStream()const;
bool getEnablePhoenix()const;
int getLogSingleStorage()const;
std::string getExpireTime()const;
bool getEnableML()const;
int getLogNum()const;
int getLocalCloudStorage()const;
bool getEnableBlob()const;
std::string getDiskThreshold()const;
bool getEnableLsqlVersionV3()const;
bool getAutoRenew()const;
bool getEnableShs()const;
std::string getMaintainEndTime()const;
@@ -94,6 +99,7 @@ namespace AlibabaCloud
std::string getMultiZoneCombination()const;
bool getEnableKms()const;
int getCoreNum()const;
std::string getArchVersion()const;
std::string getCreateTime()const;
std::string getLogSpec()const;
std::string getLocalCloudCategory()const;
@@ -107,6 +113,7 @@ namespace AlibabaCloud
long expiredMilliseconds_;
std::string standbyZoneId_;
std::vector<Engine> engineList_;
bool enableLTS_;
std::string resourceGroupId_;
bool enableBDS_;
std::string logDiskCategory_;
@@ -131,13 +138,17 @@ namespace AlibabaCloud
std::string arbiterVSwitchId_;
std::string vpcId_;
bool enableCdc_;
bool enableMLCtrl_;
bool enableStream_;
bool enablePhoenix_;
int logSingleStorage_;
std::string expireTime_;
bool enableML_;
int logNum_;
int localCloudStorage_;
bool enableBlob_;
std::string diskThreshold_;
bool enableLsqlVersionV3_;
bool autoRenew_;
bool enableShs_;
std::string maintainEndTime_;
@@ -151,6 +162,7 @@ namespace AlibabaCloud
std::string multiZoneCombination_;
bool enableKms_;
int coreNum_;
std::string archVersion_;
std::string createTime_;
std::string logSpec_;
std::string localCloudCategory_;

3
hitsdb/include/alibabacloud/hitsdb/model/ReleaseLindormInstanceRequest.h
View File

@@ -32,6 +32,8 @@ public:
~ReleaseLindormInstanceRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
bool getImmediately() const;
void setImmediately(bool immediately);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getSecurityToken() const;
@@ -47,6 +49,7 @@ public:
private:
long resourceOwnerId_;
bool immediately_;
std::string accessKeyId_;
std::string securityToken_;
std::string resourceOwnerAccount_;

3
hitsdb/include/alibabacloud/hitsdb/model/UpdateInstanceIpWhiteListRequest.h
View File

@@ -32,6 +32,8 @@ public:
~UpdateInstanceIpWhiteListRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
bool get_Delete() const;
void set_Delete(bool _delete);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getSecurityToken() const;
@@ -51,6 +53,7 @@ public:
private:
long resourceOwnerId_;
bool _delete_;
std::string accessKeyId_;
std::string securityToken_;
std::string resourceOwnerAccount_;

78
hitsdb/include/alibabacloud/hitsdb/model/UpgradeLindormInstanceRequest.h
View File

@@ -32,10 +32,30 @@ public:
~UpgradeLindormInstanceRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
int getPhoenixCoreNum() const;
void setPhoenixCoreNum(int phoenixCoreNum);
std::string getPhoenixCoreSpec() const;
void setPhoenixCoreSpec(const std::string &phoenixCoreSpec);
std::string getLogSpec() const;
void setLogSpec(const std::string &logSpec);
std::string getSecurityToken() const;
void setSecurityToken(const std::string &securityToken);
int getTsdbNum() const;
void setTsdbNum(int tsdbNum);
int getSolrNum() const;
void setSolrNum(int solrNum);
long getOwnerId() const;
void setOwnerId(long ownerId);
int getLindormNum() const;
void setLindormNum(int lindormNum);
int getLtsCoreNum() const;
void setLtsCoreNum(int ltsCoreNum);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
int getMlNum() const;
void setMlNum(int mlNum);
int getStreamNum() const;
void setStreamNum(int streamNum);
int getLogSingleStorage() const;
void setLogSingleStorage(int logSingleStorage);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getUpgradeType() const;
@@ -46,18 +66,10 @@ public:
void setFilestoreSpec(const std::string &filestoreSpec);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getLogSpec() const;
void setLogSpec(const std::string &logSpec);
std::string getSecurityToken() const;
void setSecurityToken(const std::string &securityToken);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getTsdbNum() const;
void setTsdbNum(int tsdbNum);
std::string getLindormSpec() const;
void setLindormSpec(const std::string &lindormSpec);
int getSolrNum() const;
void setSolrNum(int solrNum);
int getColdStorage() const;
void setColdStorage(int coldStorage);
int getLogNum() const;
@@ -72,38 +84,36 @@ public:
void setOwnerAccount(const std::string &ownerAccount);
int getFilestoreNum() const;
void setFilestoreNum(int filestoreNum);
long getOwnerId() const;
void setOwnerId(long ownerId);
int getLindormNum() const;
void setLindormNum(int lindormNum);
int getLtsCoreNum() const;
void setLtsCoreNum(int ltsCoreNum);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getStreamSpec() const;
void setStreamSpec(const std::string &streamSpec);
std::string getMlSpec() const;
void setMlSpec(const std::string &mlSpec);
std::string getLtsCoreSpec() const;
void setLtsCoreSpec(const std::string &ltsCoreSpec);
int getClusterStorage() const;
void setClusterStorage(int clusterStorage);
int getLogSingleStorage() const;
void setLogSingleStorage(int logSingleStorage);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
private:
long resourceOwnerId_;
int phoenixCoreNum_;
std::string phoenixCoreSpec_;
std::string logSpec_;
std::string securityToken_;
int tsdbNum_;
int solrNum_;
long ownerId_;
int lindormNum_;
int ltsCoreNum_;
std::string instanceId_;
int mlNum_;
int streamNum_;
int logSingleStorage_;
std::string zoneId_;
std::string clientToken_;
std::string upgradeType_;
std::string tsdbSpec_;
std::string filestoreSpec_;
std::string accessKeyId_;
std::string logSpec_;
std::string securityToken_;
std::string regionId_;
int tsdbNum_;
std::string lindormSpec_;
int solrNum_;
int coldStorage_;
int logNum_;
std::string solrSpec_;
@@ -111,14 +121,10 @@ private:
std::string resourceOwnerAccount_;
std::string ownerAccount_;
int filestoreNum_;
long ownerId_;
int lindormNum_;
int ltsCoreNum_;
std::string instanceId_;
std::string streamSpec_;
std::string mlSpec_;
std::string ltsCoreSpec_;
int clusterStorage_;
int logSingleStorage_;
std::string zoneId_;
};
} // namespace Model
} // namespace Hitsdb

108
hitsdb/src/HitsdbClient.cc
View File

@@ -51,6 +51,42 @@ HitsdbClient::HitsdbClient(const std::string & accessKeyId, const std::string &
HitsdbClient::~HitsdbClient()
{}
HitsdbClient::CreateLdpsNamespaceOutcome HitsdbClient::createLdpsNamespace(const CreateLdpsNamespaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateLdpsNamespaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateLdpsNamespaceOutcome(CreateLdpsNamespaceResult(outcome.result()));
else
return CreateLdpsNamespaceOutcome(outcome.error());
}
void HitsdbClient::createLdpsNamespaceAsync(const CreateLdpsNamespaceRequest& request, const CreateLdpsNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createLdpsNamespace(request), context);
};
asyncExecute(new Runnable(fn));
}
HitsdbClient::CreateLdpsNamespaceOutcomeCallable HitsdbClient::createLdpsNamespaceCallable(const CreateLdpsNamespaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateLdpsNamespaceOutcome()>>(
[this, request]()
{
return this->createLdpsNamespace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HitsdbClient::CreateLindormInstanceOutcome HitsdbClient::createLindormInstance(const CreateLindormInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,78 @@ HitsdbClient::GetInstanceIpWhiteListOutcomeCallable HitsdbClient::getInstanceIpW
return task->get_future();
}
HitsdbClient::GetLdpsNamespacedQuotaOutcome HitsdbClient::getLdpsNamespacedQuota(const GetLdpsNamespacedQuotaRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetLdpsNamespacedQuotaOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetLdpsNamespacedQuotaOutcome(GetLdpsNamespacedQuotaResult(outcome.result()));
else
return GetLdpsNamespacedQuotaOutcome(outcome.error());
}
void HitsdbClient::getLdpsNamespacedQuotaAsync(const GetLdpsNamespacedQuotaRequest& request, const GetLdpsNamespacedQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getLdpsNamespacedQuota(request), context);
};
asyncExecute(new Runnable(fn));
}
HitsdbClient::GetLdpsNamespacedQuotaOutcomeCallable HitsdbClient::getLdpsNamespacedQuotaCallable(const GetLdpsNamespacedQuotaRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetLdpsNamespacedQuotaOutcome()>>(
[this, request]()
{
return this->getLdpsNamespacedQuota(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HitsdbClient::GetLdpsResourceCostOutcome HitsdbClient::getLdpsResourceCost(const GetLdpsResourceCostRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetLdpsResourceCostOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetLdpsResourceCostOutcome(GetLdpsResourceCostResult(outcome.result()));
else
return GetLdpsResourceCostOutcome(outcome.error());
}
void HitsdbClient::getLdpsResourceCostAsync(const GetLdpsResourceCostRequest& request, const GetLdpsResourceCostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getLdpsResourceCost(request), context);
};
asyncExecute(new Runnable(fn));
}
HitsdbClient::GetLdpsResourceCostOutcomeCallable HitsdbClient::getLdpsResourceCostCallable(const GetLdpsResourceCostRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetLdpsResourceCostOutcome()>>(
[this, request]()
{
return this->getLdpsResourceCost(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HitsdbClient::GetLindormInstanceOutcome HitsdbClient::getLindormInstance(const GetLindormInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

108
hitsdb/src/model/CreateLdpsNamespaceRequest.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/hitsdb/model/CreateLdpsNamespaceRequest.h>
using AlibabaCloud::Hitsdb::Model::CreateLdpsNamespaceRequest;
CreateLdpsNamespaceRequest::CreateLdpsNamespaceRequest()
: RpcServiceRequest("hitsdb", "2020-06-15", "CreateLdpsNamespace") {
setMethod(HttpRequest::Method::Post);
}
CreateLdpsNamespaceRequest::~CreateLdpsNamespaceRequest() {}
long CreateLdpsNamespaceRequest::getResourceOwnerId() const {
return resourceOwnerId_;
}
void CreateLdpsNamespaceRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::string CreateLdpsNamespaceRequest::getAccessKeyId() const {
return accessKeyId_;
}
void CreateLdpsNamespaceRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string CreateLdpsNamespaceRequest::getSecurityToken() const {
return securityToken_;
}
void CreateLdpsNamespaceRequest::setSecurityToken(const std::string &securityToken) {
securityToken_ = securityToken;
setParameter(std::string("SecurityToken"), securityToken);
}
std::string CreateLdpsNamespaceRequest::getRegionId() const {
return regionId_;
}
void CreateLdpsNamespaceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string CreateLdpsNamespaceRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
void CreateLdpsNamespaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
std::string CreateLdpsNamespaceRequest::getOwnerAccount() const {
return ownerAccount_;
}
void CreateLdpsNamespaceRequest::setOwnerAccount(const std::string &ownerAccount) {
ownerAccount_ = ownerAccount;
setParameter(std::string("OwnerAccount"), ownerAccount);
}
long CreateLdpsNamespaceRequest::getOwnerId() const {
return ownerId_;
}
void CreateLdpsNamespaceRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string CreateLdpsNamespaceRequest::getInstanceId() const {
return instanceId_;
}
void CreateLdpsNamespaceRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
std::string CreateLdpsNamespaceRequest::get_Namespace() const {
return _namespace_;
}
void CreateLdpsNamespaceRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

44
hitsdb/src/model/CreateLdpsNamespaceResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Hitsdb;
using namespace AlibabaCloud::Hitsdb::Model;
CreateLdpsNamespaceResult::CreateLdpsNamespaceResult() :
ServiceResult()
{}
CreateLdpsNamespaceResult::CreateLdpsNamespaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateLdpsNamespaceResult::~CreateLdpsNamespaceResult()
{}
void CreateLdpsNamespaceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

18
hitsdb/src/model/CreateLindormInstanceRequest.cc
View File

@@ -133,6 +133,15 @@ void CreateLindormInstanceRequest::setVSwitchId(const std::string &vSwitchId) {
setParameter(std::string("VSwitchId"), vSwitchId);
}
int CreateLindormInstanceRequest::getStreamNum() const {
return streamNum_;
}
void CreateLindormInstanceRequest::setStreamNum(int streamNum) {
streamNum_ = streamNum;
setParameter(std::string("StreamNum"), std::to_string(streamNum));
}
int CreateLindormInstanceRequest::getLogSingleStorage() const {
return logSingleStorage_;
}
@@ -358,6 +367,15 @@ void CreateLindormInstanceRequest::setFilestoreNum(int filestoreNum) {
setParameter(std::string("FilestoreNum"), std::to_string(filestoreNum));
}
std::string CreateLindormInstanceRequest::getStreamSpec() const {
return streamSpec_;
}
void CreateLindormInstanceRequest::setStreamSpec(const std::string &streamSpec) {
streamSpec_ = streamSpec;
setParameter(std::string("StreamSpec"), streamSpec);
}
std::string CreateLindormInstanceRequest::getCoreSpec() const {
return coreSpec_;
}

15
hitsdb/src/model/GetInstanceIpWhiteListResult.cc
View File

@@ -39,6 +39,16 @@ void GetInstanceIpWhiteListResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allGroupListNode = value["GroupList"]["GroupListItem"];
for (auto valueGroupListGroupListItem : allGroupListNode)
{
GroupListItem groupListObject;
if(!valueGroupListGroupListItem["GroupName"].isNull())
groupListObject.groupName = valueGroupListGroupListItem["GroupName"].asString();
if(!valueGroupListGroupListItem["SecurityIpList"].isNull())
groupListObject.securityIpList = valueGroupListGroupListItem["SecurityIpList"].asString();
groupList_.push_back(groupListObject);
}
auto allIpList = value["IpList"]["IpList"];
for (const auto &item : allIpList)
ipList_.push_back(item.asString());
@@ -47,6 +57,11 @@ void GetInstanceIpWhiteListResult::parse(const std::string &payload)
}
std::vector<GetInstanceIpWhiteListResult::GroupListItem> GetInstanceIpWhiteListResult::getGroupList()const
{
return groupList_;
}
std::vector<std::string> GetInstanceIpWhiteListResult::getIpList()const
{
return ipList_;

108
hitsdb/src/model/GetLdpsNamespacedQuotaRequest.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/hitsdb/model/GetLdpsNamespacedQuotaRequest.h>
using AlibabaCloud::Hitsdb::Model::GetLdpsNamespacedQuotaRequest;
GetLdpsNamespacedQuotaRequest::GetLdpsNamespacedQuotaRequest()
: RpcServiceRequest("hitsdb", "2020-06-15", "GetLdpsNamespacedQuota") {
setMethod(HttpRequest::Method::Post);
}
GetLdpsNamespacedQuotaRequest::~GetLdpsNamespacedQuotaRequest() {}
long GetLdpsNamespacedQuotaRequest::getResourceOwnerId() const {
return resourceOwnerId_;
}
void GetLdpsNamespacedQuotaRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::string GetLdpsNamespacedQuotaRequest::getAccessKeyId() const {
return accessKeyId_;
}
void GetLdpsNamespacedQuotaRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string GetLdpsNamespacedQuotaRequest::getSecurityToken() const {
return securityToken_;
}
void GetLdpsNamespacedQuotaRequest::setSecurityToken(const std::string &securityToken) {
securityToken_ = securityToken;
setParameter(std::string("SecurityToken"), securityToken);
}
std::string GetLdpsNamespacedQuotaRequest::getRegionId() const {
return regionId_;
}
void GetLdpsNamespacedQuotaRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string GetLdpsNamespacedQuotaRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
void GetLdpsNamespacedQuotaRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
std::string GetLdpsNamespacedQuotaRequest::getOwnerAccount() const {
return ownerAccount_;
}
void GetLdpsNamespacedQuotaRequest::setOwnerAccount(const std::string &ownerAccount) {
ownerAccount_ = ownerAccount;
setParameter(std::string("OwnerAccount"), ownerAccount);
}
long GetLdpsNamespacedQuotaRequest::getOwnerId() const {
return ownerId_;
}
void GetLdpsNamespacedQuotaRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string GetLdpsNamespacedQuotaRequest::getInstanceId() const {
return instanceId_;
}
void GetLdpsNamespacedQuotaRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
std::string GetLdpsNamespacedQuotaRequest::get_Namespace() const {
return _namespace_;
}
void GetLdpsNamespacedQuotaRequest::set_Namespace(const std::string &_namespace) {
_namespace_ = _namespace;
setParameter(std::string("Namespace"), _namespace);
}

65
hitsdb/src/model/GetLdpsNamespacedQuotaResult.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/hitsdb/model/GetLdpsNamespacedQuotaResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Hitsdb;
using namespace AlibabaCloud::Hitsdb::Model;
GetLdpsNamespacedQuotaResult::GetLdpsNamespacedQuotaResult() :
ServiceResult()
{}
GetLdpsNamespacedQuotaResult::GetLdpsNamespacedQuotaResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetLdpsNamespacedQuotaResult::~GetLdpsNamespacedQuotaResult()
{}
void GetLdpsNamespacedQuotaResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allNamespacedQuotasNode = value["NamespacedQuotas"]["NamespacedQuota"];
for (auto valueNamespacedQuotasNamespacedQuota : allNamespacedQuotasNode)
{
NamespacedQuota namespacedQuotasObject;
if(!valueNamespacedQuotasNamespacedQuota["Name"].isNull())
namespacedQuotasObject.name = valueNamespacedQuotasNamespacedQuota["Name"].asString();
if(!valueNamespacedQuotasNamespacedQuota["CpuAmount"].isNull())
namespacedQuotasObject.cpuAmount = valueNamespacedQuotasNamespacedQuota["CpuAmount"].asString();
if(!valueNamespacedQuotasNamespacedQuota["MemoryAmount"].isNull())
namespacedQuotasObject.memoryAmount = valueNamespacedQuotasNamespacedQuota["MemoryAmount"].asString();
if(!valueNamespacedQuotasNamespacedQuota["UsedCpu"].isNull())
namespacedQuotasObject.usedCpu = valueNamespacedQuotasNamespacedQuota["UsedCpu"].asString();
if(!valueNamespacedQuotasNamespacedQuota["UsedMemory"].isNull())
namespacedQuotasObject.usedMemory = valueNamespacedQuotasNamespacedQuota["UsedMemory"].asString();
namespacedQuotas_.push_back(namespacedQuotasObject);
}
}
std::vector<GetLdpsNamespacedQuotaResult::NamespacedQuota> GetLdpsNamespacedQuotaResult::getNamespacedQuotas()const
{
return namespacedQuotas_;
}

126
hitsdb/src/model/GetLdpsResourceCostRequest.cc Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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/hitsdb/model/GetLdpsResourceCostRequest.h>
using AlibabaCloud::Hitsdb::Model::GetLdpsResourceCostRequest;
GetLdpsResourceCostRequest::GetLdpsResourceCostRequest()
: RpcServiceRequest("hitsdb", "2020-06-15", "GetLdpsResourceCost") {
setMethod(HttpRequest::Method::Post);
}
GetLdpsResourceCostRequest::~GetLdpsResourceCostRequest() {}
long GetLdpsResourceCostRequest::getResourceOwnerId() const {
return resourceOwnerId_;
}
void GetLdpsResourceCostRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
long GetLdpsResourceCostRequest::getStartTime() const {
return startTime_;
}
void GetLdpsResourceCostRequest::setStartTime(long startTime) {
startTime_ = startTime;
setParameter(std::string("StartTime"), std::to_string(startTime));
}
std::string GetLdpsResourceCostRequest::getAccessKeyId() const {
return accessKeyId_;
}
void GetLdpsResourceCostRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string GetLdpsResourceCostRequest::getJobId() const {
return jobId_;
}
void GetLdpsResourceCostRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), jobId);
}
std::string GetLdpsResourceCostRequest::getSecurityToken() const {
return securityToken_;
}
void GetLdpsResourceCostRequest::setSecurityToken(const std::string &securityToken) {
securityToken_ = securityToken;
setParameter(std::string("SecurityToken"), securityToken);
}
std::string GetLdpsResourceCostRequest::getRegionId() const {
return regionId_;
}
void GetLdpsResourceCostRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string GetLdpsResourceCostRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
void GetLdpsResourceCostRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
std::string GetLdpsResourceCostRequest::getOwnerAccount() const {
return ownerAccount_;
}
void GetLdpsResourceCostRequest::setOwnerAccount(const std::string &ownerAccount) {
ownerAccount_ = ownerAccount;
setParameter(std::string("OwnerAccount"), ownerAccount);
}
long GetLdpsResourceCostRequest::getEndTime() const {
return endTime_;
}
void GetLdpsResourceCostRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
long GetLdpsResourceCostRequest::getOwnerId() const {
return ownerId_;
}
void GetLdpsResourceCostRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string GetLdpsResourceCostRequest::getInstanceId() const {
return instanceId_;
}
void GetLdpsResourceCostRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}

79
hitsdb/src/model/GetLdpsResourceCostResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* 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/hitsdb/model/GetLdpsResourceCostResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Hitsdb;
using namespace AlibabaCloud::Hitsdb::Model;
GetLdpsResourceCostResult::GetLdpsResourceCostResult() :
ServiceResult()
{}
GetLdpsResourceCostResult::GetLdpsResourceCostResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetLdpsResourceCostResult::~GetLdpsResourceCostResult()
{}
void GetLdpsResourceCostResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["InstanceId"].isNull())
instanceId_ = value["InstanceId"].asString();
if(!value["JobId"].isNull())
jobId_ = value["JobId"].asString();
if(!value["StartTime"].isNull())
startTime_ = std::stol(value["StartTime"].asString());
if(!value["EndTime"].isNull())
endTime_ = std::stol(value["EndTime"].asString());
if(!value["TotalResource"].isNull())
totalResource_ = std::stol(value["TotalResource"].asString());
}
long GetLdpsResourceCostResult::getEndTime()const
{
return endTime_;
}
std::string GetLdpsResourceCostResult::getInstanceId()const
{
return instanceId_;
}
long GetLdpsResourceCostResult::getStartTime()const
{
return startTime_;
}
long GetLdpsResourceCostResult::getTotalResource()const
{
return totalResource_;
}
std::string GetLdpsResourceCostResult::getJobId()const
{
return jobId_;
}

42
hitsdb/src/model/GetLindormInstanceResult.cc
View File

@@ -73,6 +73,8 @@ void GetLindormInstanceResult::parse(const std::string &payload)
serviceType_ = value["ServiceType"].asString();
if(!value["EnableKms"].isNull())
enableKms_ = value["EnableKms"].asString() == "true";
if(!value["EnableML"].isNull())
enableML_ = value["EnableML"].asString() == "true";
if(!value["DiskUsage"].isNull())
diskUsage_ = value["DiskUsage"].asString();
if(!value["DiskCategory"].isNull())
@@ -117,12 +119,18 @@ void GetLindormInstanceResult::parse(const std::string &payload)
enableCompute_ = value["EnableCompute"].asString() == "true";
if(!value["EnableSSL"].isNull())
enableSSL_ = value["EnableSSL"].asString() == "true";
if(!value["EnableMLCtrl"].isNull())
enableMLCtrl_ = value["EnableMLCtrl"].asString() == "true";
if(!value["EnableCdc"].isNull())
enableCdc_ = value["EnableCdc"].asString() == "true";
if(!value["EnableStream"].isNull())
enableStream_ = value["EnableStream"].asString() == "true";
if(!value["EnableLTS"].isNull())
enableLTS_ = value["EnableLTS"].asString() == "true";
if(!value["EnableShs"].isNull())
enableShs_ = value["EnableShs"].asString() == "true";
if(!value["EnableBlob"].isNull())
enableBlob_ = value["EnableBlob"].asString() == "true";
if(!value["MaintainStartTime"].isNull())
maintainStartTime_ = value["MaintainStartTime"].asString();
if(!value["MaintainEndTime"].isNull())
@@ -163,6 +171,10 @@ void GetLindormInstanceResult::parse(const std::string &payload)
logNum_ = std::stoi(value["LogNum"].asString());
if(!value["LogSingleStorage"].isNull())
logSingleStorage_ = std::stoi(value["LogSingleStorage"].asString());
if(!value["ArchVersion"].isNull())
archVersion_ = value["ArchVersion"].asString();
if(!value["EnableLsqlVersionV3"].isNull())
enableLsqlVersionV3_ = value["EnableLsqlVersionV3"].asString() == "true";
}
@@ -181,6 +193,11 @@ std::vector<GetLindormInstanceResult::Engine> GetLindormInstanceResult::getEngin
return engineList_;
}
bool GetLindormInstanceResult::getEnableLTS()const
{
return enableLTS_;
}
std::string GetLindormInstanceResult::getResourceGroupId()const
{
return resourceGroupId_;
@@ -301,6 +318,11 @@ bool GetLindormInstanceResult::getEnableCdc()const
return enableCdc_;
}
bool GetLindormInstanceResult::getEnableMLCtrl()const
{
return enableMLCtrl_;
}
bool GetLindormInstanceResult::getEnableStream()const
{
return enableStream_;
@@ -321,6 +343,11 @@ std::string GetLindormInstanceResult::getExpireTime()const
return expireTime_;
}
bool GetLindormInstanceResult::getEnableML()const
{
return enableML_;
}
int GetLindormInstanceResult::getLogNum()const
{
return logNum_;
@@ -331,11 +358,21 @@ int GetLindormInstanceResult::getLocalCloudStorage()const
return localCloudStorage_;
}
bool GetLindormInstanceResult::getEnableBlob()const
{
return enableBlob_;
}
std::string GetLindormInstanceResult::getDiskThreshold()const
{
return diskThreshold_;
}
bool GetLindormInstanceResult::getEnableLsqlVersionV3()const
{
return enableLsqlVersionV3_;
}
bool GetLindormInstanceResult::getAutoRenew()const
{
return autoRenew_;
@@ -401,6 +438,11 @@ int GetLindormInstanceResult::getCoreNum()const
return coreNum_;
}
std::string GetLindormInstanceResult::getArchVersion()const
{
return archVersion_;
}
std::string GetLindormInstanceResult::getCreateTime()const
{
return createTime_;

9
hitsdb/src/model/ReleaseLindormInstanceRequest.cc
View File

@@ -34,6 +34,15 @@ void ReleaseLindormInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
bool ReleaseLindormInstanceRequest::getImmediately() const {
return immediately_;
}
void ReleaseLindormInstanceRequest::setImmediately(bool immediately) {
immediately_ = immediately;
setParameter(std::string("Immediately"), immediately ? "true" : "false");
}
std::string ReleaseLindormInstanceRequest::getAccessKeyId() const {
return accessKeyId_;
}

9
hitsdb/src/model/UpdateInstanceIpWhiteListRequest.cc
View File

@@ -34,6 +34,15 @@ void UpdateInstanceIpWhiteListRequest::setResourceOwnerId(long resourceOwnerId)
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
bool UpdateInstanceIpWhiteListRequest::get_Delete() const {
return _delete_;
}
void UpdateInstanceIpWhiteListRequest::set_Delete(bool _delete) {
_delete_ = _delete;
setParameter(std::string("Delete"), _delete ? "true" : "false");
}
std::string UpdateInstanceIpWhiteListRequest::getAccessKeyId() const {
return accessKeyId_;
}

202
hitsdb/src/model/UpgradeLindormInstanceRequest.cc
View File

@@ -34,22 +34,112 @@ void UpgradeLindormInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
int UpgradeLindormInstanceRequest::getPhoenixCoreNum() const {
return phoenixCoreNum_;
std::string UpgradeLindormInstanceRequest::getLogSpec() const {
return logSpec_;
}
void UpgradeLindormInstanceRequest::setPhoenixCoreNum(int phoenixCoreNum) {
phoenixCoreNum_ = phoenixCoreNum;
setParameter(std::string("PhoenixCoreNum"), std::to_string(phoenixCoreNum));
void UpgradeLindormInstanceRequest::setLogSpec(const std::string &logSpec) {
logSpec_ = logSpec;
setParameter(std::string("LogSpec"), logSpec);
}
std::string UpgradeLindormInstanceRequest::getPhoenixCoreSpec() const {
return phoenixCoreSpec_;
std::string UpgradeLindormInstanceRequest::getSecurityToken() const {
return securityToken_;
}
void UpgradeLindormInstanceRequest::setPhoenixCoreSpec(const std::string &phoenixCoreSpec) {
phoenixCoreSpec_ = phoenixCoreSpec;
setParameter(std::string("PhoenixCoreSpec"), phoenixCoreSpec);
void UpgradeLindormInstanceRequest::setSecurityToken(const std::string &securityToken) {
securityToken_ = securityToken;
setParameter(std::string("SecurityToken"), securityToken);
}
int UpgradeLindormInstanceRequest::getTsdbNum() const {
return tsdbNum_;
}
void UpgradeLindormInstanceRequest::setTsdbNum(int tsdbNum) {
tsdbNum_ = tsdbNum;
setParameter(std::string("TsdbNum"), std::to_string(tsdbNum));
}
int UpgradeLindormInstanceRequest::getSolrNum() const {
return solrNum_;
}
void UpgradeLindormInstanceRequest::setSolrNum(int solrNum) {
solrNum_ = solrNum;
setParameter(std::string("SolrNum"), std::to_string(solrNum));
}
long UpgradeLindormInstanceRequest::getOwnerId() const {
return ownerId_;
}
void UpgradeLindormInstanceRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
int UpgradeLindormInstanceRequest::getLindormNum() const {
return lindormNum_;
}
void UpgradeLindormInstanceRequest::setLindormNum(int lindormNum) {
lindormNum_ = lindormNum;
setParameter(std::string("LindormNum"), std::to_string(lindormNum));
}
int UpgradeLindormInstanceRequest::getLtsCoreNum() const {
return ltsCoreNum_;
}
void UpgradeLindormInstanceRequest::setLtsCoreNum(int ltsCoreNum) {
ltsCoreNum_ = ltsCoreNum;
setParameter(std::string("LtsCoreNum"), std::to_string(ltsCoreNum));
}
std::string UpgradeLindormInstanceRequest::getInstanceId() const {
return instanceId_;
}
void UpgradeLindormInstanceRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
int UpgradeLindormInstanceRequest::getMlNum() const {
return mlNum_;
}
void UpgradeLindormInstanceRequest::setMlNum(int mlNum) {
mlNum_ = mlNum;
setParameter(std::string("MlNum"), std::to_string(mlNum));
}
int UpgradeLindormInstanceRequest::getStreamNum() const {
return streamNum_;
}
void UpgradeLindormInstanceRequest::setStreamNum(int streamNum) {
streamNum_ = streamNum;
setParameter(std::string("StreamNum"), std::to_string(streamNum));
}
int UpgradeLindormInstanceRequest::getLogSingleStorage() const {
return logSingleStorage_;
}
void UpgradeLindormInstanceRequest::setLogSingleStorage(int logSingleStorage) {
logSingleStorage_ = logSingleStorage;
setParameter(std::string("LogSingleStorage"), std::to_string(logSingleStorage));
}
std::string UpgradeLindormInstanceRequest::getZoneId() const {
return zoneId_;
}
void UpgradeLindormInstanceRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
std::string UpgradeLindormInstanceRequest::getClientToken() const {
@@ -97,24 +187,6 @@ void UpgradeLindormInstanceRequest::setAccessKeyId(const std::string &accessKeyI
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string UpgradeLindormInstanceRequest::getLogSpec() const {
return logSpec_;
}
void UpgradeLindormInstanceRequest::setLogSpec(const std::string &logSpec) {
logSpec_ = logSpec;
setParameter(std::string("LogSpec"), logSpec);
}
std::string UpgradeLindormInstanceRequest::getSecurityToken() const {
return securityToken_;
}
void UpgradeLindormInstanceRequest::setSecurityToken(const std::string &securityToken) {
securityToken_ = securityToken;
setParameter(std::string("SecurityToken"), securityToken);
}
std::string UpgradeLindormInstanceRequest::getRegionId() const {
return regionId_;
}
@@ -124,15 +196,6 @@ void UpgradeLindormInstanceRequest::setRegionId(const std::string &regionId) {
setParameter(std::string("RegionId"), regionId);
}
int UpgradeLindormInstanceRequest::getTsdbNum() const {
return tsdbNum_;
}
void UpgradeLindormInstanceRequest::setTsdbNum(int tsdbNum) {
tsdbNum_ = tsdbNum;
setParameter(std::string("TsdbNum"), std::to_string(tsdbNum));
}
std::string UpgradeLindormInstanceRequest::getLindormSpec() const {
return lindormSpec_;
}
@@ -142,15 +205,6 @@ void UpgradeLindormInstanceRequest::setLindormSpec(const std::string &lindormSpe
setParameter(std::string("LindormSpec"), lindormSpec);
}
int UpgradeLindormInstanceRequest::getSolrNum() const {
return solrNum_;
}
void UpgradeLindormInstanceRequest::setSolrNum(int solrNum) {
solrNum_ = solrNum;
setParameter(std::string("SolrNum"), std::to_string(solrNum));
}
int UpgradeLindormInstanceRequest::getColdStorage() const {
return coldStorage_;
}
@@ -214,40 +268,22 @@ void UpgradeLindormInstanceRequest::setFilestoreNum(int filestoreNum) {
setParameter(std::string("FilestoreNum"), std::to_string(filestoreNum));
}
long UpgradeLindormInstanceRequest::getOwnerId() const {
return ownerId_;
std::string UpgradeLindormInstanceRequest::getStreamSpec() const {
return streamSpec_;
}
void UpgradeLindormInstanceRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
void UpgradeLindormInstanceRequest::setStreamSpec(const std::string &streamSpec) {
streamSpec_ = streamSpec;
setParameter(std::string("StreamSpec"), streamSpec);
}
int UpgradeLindormInstanceRequest::getLindormNum() const {
return lindormNum_;
std::string UpgradeLindormInstanceRequest::getMlSpec() const {
return mlSpec_;
}
void UpgradeLindormInstanceRequest::setLindormNum(int lindormNum) {
lindormNum_ = lindormNum;
setParameter(std::string("LindormNum"), std::to_string(lindormNum));
}
int UpgradeLindormInstanceRequest::getLtsCoreNum() const {
return ltsCoreNum_;
}
void UpgradeLindormInstanceRequest::setLtsCoreNum(int ltsCoreNum) {
ltsCoreNum_ = ltsCoreNum;
setParameter(std::string("LtsCoreNum"), std::to_string(ltsCoreNum));
}
std::string UpgradeLindormInstanceRequest::getInstanceId() const {
return instanceId_;
}
void UpgradeLindormInstanceRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
void UpgradeLindormInstanceRequest::setMlSpec(const std::string &mlSpec) {
mlSpec_ = mlSpec;
setParameter(std::string("MlSpec"), mlSpec);
}
std::string UpgradeLindormInstanceRequest::getLtsCoreSpec() const {
@@ -268,21 +304,3 @@ void UpgradeLindormInstanceRequest::setClusterStorage(int clusterStorage) {
setParameter(std::string("ClusterStorage"), std::to_string(clusterStorage));
}
int UpgradeLindormInstanceRequest::getLogSingleStorage() const {
return logSingleStorage_;
}
void UpgradeLindormInstanceRequest::setLogSingleStorage(int logSingleStorage) {
logSingleStorage_ = logSingleStorage;
setParameter(std::string("LogSingleStorage"), std::to_string(logSingleStorage));
}
std::string UpgradeLindormInstanceRequest::getZoneId() const {
return zoneId_;
}
void UpgradeLindormInstanceRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}