hbase-20190101/main.tea (7,044 lines of code) (raw):
/**
*
*/
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;
extends OpenApi;
init(config: OpenApi.Config){
super(config);
@endpointRule = 'regional';
@endpointMap = {
ap-northeast-2-pop = 'hbase.aliyuncs.com',
ap-south-1 = 'hbase.aliyuncs.com',
ap-southeast-2 = 'hbase.aliyuncs.com',
cn-beijing-finance-1 = 'hbase.aliyuncs.com',
cn-beijing-finance-pop = 'hbase.aliyuncs.com',
cn-beijing-gov-1 = 'hbase.aliyuncs.com',
cn-beijing-nu16-b01 = 'hbase.aliyuncs.com',
cn-edge-1 = 'hbase.aliyuncs.com',
cn-fujian = 'hbase.aliyuncs.com',
cn-haidian-cm12-c01 = 'hbase.aliyuncs.com',
cn-hangzhou-bj-b01 = 'hbase.aliyuncs.com',
cn-hangzhou-internal-prod-1 = 'hbase.aliyuncs.com',
cn-hangzhou-internal-test-1 = 'hbase.aliyuncs.com',
cn-hangzhou-internal-test-2 = 'hbase.aliyuncs.com',
cn-hangzhou-internal-test-3 = 'hbase.aliyuncs.com',
cn-hangzhou-test-306 = 'hbase.aliyuncs.com',
cn-hongkong-finance-pop = 'hbase.aliyuncs.com',
cn-qingdao-nebula = 'hbase.aliyuncs.com',
cn-shanghai-et15-b01 = 'hbase.aliyuncs.com',
cn-shanghai-et2-b01 = 'hbase.aliyuncs.com',
cn-shanghai-inner = 'hbase.aliyuncs.com',
cn-shanghai-internal-test-1 = 'hbase.aliyuncs.com',
cn-shenzhen-inner = 'hbase.aliyuncs.com',
cn-shenzhen-st4-d01 = 'hbase.aliyuncs.com',
cn-shenzhen-su18-b01 = 'hbase.aliyuncs.com',
cn-wuhan = 'hbase.aliyuncs.com',
cn-wulanchabu = 'hbase.aliyuncs.com',
cn-yushanfang = 'hbase.aliyuncs.com',
cn-zhangbei = 'hbase.aliyuncs.com',
cn-zhangbei-na61-b01 = 'hbase.aliyuncs.com',
cn-zhangjiakou-na62-a01 = 'hbase.aliyuncs.com',
cn-zhengzhou-nebula-1 = 'hbase.aliyuncs.com',
eu-west-1-oxs = 'hbase.aliyuncs.com',
rus-west-1-pop = 'hbase.aliyuncs.com',
};
checkConfig(config);
@endpoint = getEndpoint('hbase', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}
function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
if (!Util.empty(endpoint)) {
return endpoint;
}
if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
return endpointMap[regionId];
}
return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}
model AddUserHdfsInfoRequest {
clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd5****582s'),
extInfo?: string(name='ExtInfo', description='This parameter is required.', example='{"dfs.nameservices":"hdfs_test","dfs.ha.namenodes":"nn1,nn2","dfs.namenode.http-address.hdfs_test.nn1":"TEST-xxx1.com:50070","dfs.namenode.http-address.hdfs_test.nn2":"TEST-xxx2.com:50070","dfs.namenode.rpc-address.hdfs_test.nn1":"TEST-xxx1.com:8020","dfs.namenode.rpc-address.hdfs_test.nn2":"TEST-xxx2.com:8020"}'),
}
model AddUserHdfsInfoResponseBody = {
requestId?: string(name='RequestId', example='FB0B7918-198C-46A8-AB9B-FE15403B1F0A'),
}
model AddUserHdfsInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: AddUserHdfsInfoResponseBody(name='body'),
}
/**
* @param request AddUserHdfsInfoRequest
* @param runtime runtime options for this request RuntimeOptions
* @return AddUserHdfsInfoResponse
*/
async function addUserHdfsInfoWithOptions(request: AddUserHdfsInfoRequest, runtime: Util.RuntimeOptions): AddUserHdfsInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.extInfo)) {
query['ExtInfo'] = request.extInfo;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'AddUserHdfsInfo',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request AddUserHdfsInfoRequest
* @return AddUserHdfsInfoResponse
*/
async function addUserHdfsInfo(request: AddUserHdfsInfoRequest): AddUserHdfsInfoResponse {
var runtime = new Util.RuntimeOptions{};
return addUserHdfsInfoWithOptions(request, runtime);
}
model AllocatePublicNetworkAddressRequest {
clientToken?: string(name='ClientToken', example='83b2b5e117a5b8bce0fae88d90576a84_6452320_82718582'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
}
model AllocatePublicNetworkAddressResponseBody = {
requestId?: string(name='RequestId'),
}
model AllocatePublicNetworkAddressResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: AllocatePublicNetworkAddressResponseBody(name='body'),
}
/**
* @param request AllocatePublicNetworkAddressRequest
* @param runtime runtime options for this request RuntimeOptions
* @return AllocatePublicNetworkAddressResponse
*/
async function allocatePublicNetworkAddressWithOptions(request: AllocatePublicNetworkAddressRequest, runtime: Util.RuntimeOptions): AllocatePublicNetworkAddressResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'AllocatePublicNetworkAddress',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request AllocatePublicNetworkAddressRequest
* @return AllocatePublicNetworkAddressResponse
*/
async function allocatePublicNetworkAddress(request: AllocatePublicNetworkAddressRequest): AllocatePublicNetworkAddressResponse {
var runtime = new Util.RuntimeOptions{};
return allocatePublicNetworkAddressWithOptions(request, runtime);
}
model CancelActiveOperationTasksRequest {
ids?: string(name='Ids', description='This parameter is required.', example='11111,22222'),
ownerAccount?: string(name='OwnerAccount'),
ownerId?: long(name='OwnerId'),
resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
resourceOwnerId?: long(name='ResourceOwnerId'),
securityToken?: string(name='SecurityToken'),
}
model CancelActiveOperationTasksResponseBody = {
ids?: string(name='Ids', example='11111,22222'),
requestId?: string(name='RequestId', example='AE4F6C34-065F-45AA-F5BN-4B8D816F6305'),
}
model CancelActiveOperationTasksResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CancelActiveOperationTasksResponseBody(name='body'),
}
/**
* @param request CancelActiveOperationTasksRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CancelActiveOperationTasksResponse
*/
async function cancelActiveOperationTasksWithOptions(request: CancelActiveOperationTasksRequest, runtime: Util.RuntimeOptions): CancelActiveOperationTasksResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.ids)) {
query['Ids'] = request.ids;
}
if (!Util.isUnset(request.ownerAccount)) {
query['OwnerAccount'] = request.ownerAccount;
}
if (!Util.isUnset(request.ownerId)) {
query['OwnerId'] = request.ownerId;
}
if (!Util.isUnset(request.resourceOwnerAccount)) {
query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
}
if (!Util.isUnset(request.resourceOwnerId)) {
query['ResourceOwnerId'] = request.resourceOwnerId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CancelActiveOperationTasks',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CancelActiveOperationTasksRequest
* @return CancelActiveOperationTasksResponse
*/
async function cancelActiveOperationTasks(request: CancelActiveOperationTasksRequest): CancelActiveOperationTasksResponse {
var runtime = new Util.RuntimeOptions{};
return cancelActiveOperationTasksWithOptions(request, runtime);
}
model CheckComponentsVersionRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
components?: string(name='Components', description='This parameter is required.', example='HBASE,HADOOP'),
}
model CheckComponentsVersionResponseBody = {
components?: {
component?: [
{
component?: string(name='Component', example='HBASE'),
isLatestVersion?: string(name='IsLatestVersion', example='true'),
}
](name='Component')
}(name='Components'),
requestId?: string(name='RequestId', example='E3537EB4-1100-41CA-A147-C74CCC8BB12C'),
}
model CheckComponentsVersionResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CheckComponentsVersionResponseBody(name='body'),
}
/**
* @param request CheckComponentsVersionRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CheckComponentsVersionResponse
*/
async function checkComponentsVersionWithOptions(request: CheckComponentsVersionRequest, runtime: Util.RuntimeOptions): CheckComponentsVersionResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.components)) {
query['Components'] = request.components;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CheckComponentsVersion',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CheckComponentsVersionRequest
* @return CheckComponentsVersionResponse
*/
async function checkComponentsVersion(request: CheckComponentsVersionRequest): CheckComponentsVersionResponse {
var runtime = new Util.RuntimeOptions{};
return checkComponentsVersionWithOptions(request, runtime);
}
model CloseBackupRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
}
model CloseBackupResponseBody = {
requestId?: string(name='RequestId', example='F1A11940-0C34-4385-864F-A01E29B55F6A'),
}
model CloseBackupResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CloseBackupResponseBody(name='body'),
}
/**
* @param request CloseBackupRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CloseBackupResponse
*/
async function closeBackupWithOptions(request: CloseBackupRequest, runtime: Util.RuntimeOptions): CloseBackupResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CloseBackup',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CloseBackupRequest
* @return CloseBackupResponse
*/
async function closeBackup(request: CloseBackupRequest): CloseBackupResponse {
var runtime = new Util.RuntimeOptions{};
return closeBackupWithOptions(request, runtime);
}
model ConvertInstanceRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
duration?: int32(name='Duration', example='7'),
payType?: string(name='PayType', example='Prepaid'),
pricingCycle?: string(name='PricingCycle', example='month'),
}
model ConvertInstanceResponseBody = {
orderId?: long(name='OrderId', example='54124548879'),
requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}
model ConvertInstanceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ConvertInstanceResponseBody(name='body'),
}
/**
* @param request ConvertInstanceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ConvertInstanceResponse
*/
async function convertInstanceWithOptions(request: ConvertInstanceRequest, runtime: Util.RuntimeOptions): ConvertInstanceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.duration)) {
query['Duration'] = request.duration;
}
if (!Util.isUnset(request.payType)) {
query['PayType'] = request.payType;
}
if (!Util.isUnset(request.pricingCycle)) {
query['PricingCycle'] = request.pricingCycle;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ConvertInstance',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ConvertInstanceRequest
* @return ConvertInstanceResponse
*/
async function convertInstance(request: ConvertInstanceRequest): ConvertInstanceResponse {
var runtime = new Util.RuntimeOptions{};
return convertInstanceWithOptions(request, runtime);
}
model CreateAccountRequest {
accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
accountPassword?: string(name='AccountPassword', description='This parameter is required.', example='**********'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}
model CreateAccountResponseBody = {
requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}
model CreateAccountResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateAccountResponseBody(name='body'),
}
/**
* @summary 新建账户
*
* @param request CreateAccountRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateAccountResponse
*/
async function createAccountWithOptions(request: CreateAccountRequest, runtime: Util.RuntimeOptions): CreateAccountResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.accountName)) {
query['AccountName'] = request.accountName;
}
if (!Util.isUnset(request.accountPassword)) {
query['AccountPassword'] = request.accountPassword;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateAccount',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @summary 新建账户
*
* @param request CreateAccountRequest
* @return CreateAccountResponse
*/
async function createAccount(request: CreateAccountRequest): CreateAccountResponse {
var runtime = new Util.RuntimeOptions{};
return createAccountWithOptions(request, runtime);
}
model CreateBackupPlanRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-wz94lbcqc****4x93'),
}
model CreateBackupPlanResponseBody = {
requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}
model CreateBackupPlanResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateBackupPlanResponseBody(name='body'),
}
/**
* @param request CreateBackupPlanRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateBackupPlanResponse
*/
async function createBackupPlanWithOptions(request: CreateBackupPlanRequest, runtime: Util.RuntimeOptions): CreateBackupPlanResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateBackupPlan',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CreateBackupPlanRequest
* @return CreateBackupPlanResponse
*/
async function createBackupPlan(request: CreateBackupPlanRequest): CreateBackupPlanResponse {
var runtime = new Util.RuntimeOptions{};
return createBackupPlanWithOptions(request, runtime);
}
model CreateClusterRequest {
autoRenewPeriod?: int32(name='AutoRenewPeriod', example='2'),
clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
clusterName?: string(name='ClusterName', example='hbase_test'),
coldStorageSize?: int32(name='ColdStorageSize', example='1024'),
coreInstanceType?: string(name='CoreInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
diskSize?: int32(name='DiskSize', example='400'),
diskType?: string(name='DiskType', example='cloud_ssd'),
encryptionKey?: string(name='EncryptionKey', example='0d2470df-da7b-4786-b981-9a164dae****'),
engine?: string(name='Engine', description='This parameter is required.', example='hbase'),
engineVersion?: string(name='EngineVersion', description='This parameter is required.', example='2.0'),
masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.medium'),
nodeCount?: int32(name='NodeCount', description='This parameter is required.', example='2'),
payType?: string(name='PayType', description='This parameter is required.', example='Prepaid'),
period?: int32(name='Period', example='6'),
periodUnit?: string(name='PeriodUnit', example='month'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
resourceGroupId?: string(name='ResourceGroupId', example='rg-j4d53glb3****'),
securityIPList?: string(name='SecurityIPList', example='116.62.XX.XX/24'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp191otqj1ssyl****'),
vpcId?: string(name='VpcId', example='vpc-bp120k6ixs4eog****'),
zoneId?: string(name='ZoneId', description='This parameter is required.', example='cn-hangzhou-f'),
}
model CreateClusterResponseBody = {
clusterId?: string(name='ClusterId', example='hb-bp1hy2sjf8gd****'),
orderId?: string(name='OrderId', example='23232069786****'),
requestId?: string(name='RequestId', example='3E19E345-101D-4014-946C-A205'),
}
model CreateClusterResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateClusterResponseBody(name='body'),
}
/**
* @param request CreateClusterRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateClusterResponse
*/
async function createClusterWithOptions(request: CreateClusterRequest, runtime: Util.RuntimeOptions): CreateClusterResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.autoRenewPeriod)) {
query['AutoRenewPeriod'] = request.autoRenewPeriod;
}
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clusterName)) {
query['ClusterName'] = request.clusterName;
}
if (!Util.isUnset(request.coldStorageSize)) {
query['ColdStorageSize'] = request.coldStorageSize;
}
if (!Util.isUnset(request.coreInstanceType)) {
query['CoreInstanceType'] = request.coreInstanceType;
}
if (!Util.isUnset(request.diskSize)) {
query['DiskSize'] = request.diskSize;
}
if (!Util.isUnset(request.diskType)) {
query['DiskType'] = request.diskType;
}
if (!Util.isUnset(request.encryptionKey)) {
query['EncryptionKey'] = request.encryptionKey;
}
if (!Util.isUnset(request.engine)) {
query['Engine'] = request.engine;
}
if (!Util.isUnset(request.engineVersion)) {
query['EngineVersion'] = request.engineVersion;
}
if (!Util.isUnset(request.masterInstanceType)) {
query['MasterInstanceType'] = request.masterInstanceType;
}
if (!Util.isUnset(request.nodeCount)) {
query['NodeCount'] = request.nodeCount;
}
if (!Util.isUnset(request.payType)) {
query['PayType'] = request.payType;
}
if (!Util.isUnset(request.period)) {
query['Period'] = request.period;
}
if (!Util.isUnset(request.periodUnit)) {
query['PeriodUnit'] = request.periodUnit;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceGroupId)) {
query['ResourceGroupId'] = request.resourceGroupId;
}
if (!Util.isUnset(request.securityIPList)) {
query['SecurityIPList'] = request.securityIPList;
}
if (!Util.isUnset(request.vSwitchId)) {
query['VSwitchId'] = request.vSwitchId;
}
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateCluster',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CreateClusterRequest
* @return CreateClusterResponse
*/
async function createCluster(request: CreateClusterRequest): CreateClusterResponse {
var runtime = new Util.RuntimeOptions{};
return createClusterWithOptions(request, runtime);
}
model CreateGlobalResourceRequest {
clientToken?: string(name='ClientToken', example='xxxxx-xxxxx-xxxxx'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
regionId?: string(name='RegionId'),
resourceName?: string(name='ResourceName', description='This parameter is required.', example='PubPhoenixSLBQueryServerVip'),
resourceType?: string(name='ResourceType', description='This parameter is required.', example='GLOBAL_VIP'),
}
model CreateGlobalResourceResponseBody = {
requestId?: string(name='RequestId', example='1AB9ABDF-7E1E-44AD-8610-70A005115DD1'),
}
model CreateGlobalResourceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateGlobalResourceResponseBody(name='body'),
}
/**
* @param request CreateGlobalResourceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateGlobalResourceResponse
*/
async function createGlobalResourceWithOptions(request: CreateGlobalResourceRequest, runtime: Util.RuntimeOptions): CreateGlobalResourceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceName)) {
query['ResourceName'] = request.resourceName;
}
if (!Util.isUnset(request.resourceType)) {
query['ResourceType'] = request.resourceType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateGlobalResource',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CreateGlobalResourceRequest
* @return CreateGlobalResourceResponse
*/
async function createGlobalResource(request: CreateGlobalResourceRequest): CreateGlobalResourceResponse {
var runtime = new Util.RuntimeOptions{};
return createGlobalResourceWithOptions(request, runtime);
}
model CreateHBaseSlbServerRequest {
clientToken?: string(name='ClientToken', example='xxxxx-xxxxx-xxxxx'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
slbServer?: string(name='SlbServer', description='This parameter is required.', example='thrift'),
}
model CreateHBaseSlbServerResponseBody = {
requestId?: string(name='RequestId', example='61FC5B21-87B0-41BC-9686-9DA395EB40B6'),
}
model CreateHBaseSlbServerResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateHBaseSlbServerResponseBody(name='body'),
}
/**
* @param request CreateHBaseSlbServerRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateHBaseSlbServerResponse
*/
async function createHBaseSlbServerWithOptions(request: CreateHBaseSlbServerRequest, runtime: Util.RuntimeOptions): CreateHBaseSlbServerResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.slbServer)) {
query['SlbServer'] = request.slbServer;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateHBaseSlbServer',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CreateHBaseSlbServerRequest
* @return CreateHBaseSlbServerResponse
*/
async function createHBaseSlbServer(request: CreateHBaseSlbServerRequest): CreateHBaseSlbServerResponse {
var runtime = new Util.RuntimeOptions{};
return createHBaseSlbServerWithOptions(request, runtime);
}
model CreateHbaseHaSlbRequest {
bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-t4n3496whj23****'),
clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
haId?: string(name='HaId', description='This parameter is required.', example='ha-v21tmnxjwh2yu****'),
haTypes?: string(name='HaTypes', description='This parameter is required.', example='thrift'),
hbaseType?: string(name='HbaseType', description='This parameter is required.', example='Active'),
}
model CreateHbaseHaSlbResponseBody = {
requestId?: string(name='RequestId', example='C9D568D9-A59C-4AF2-8FBB-F086A841D58E'),
}
model CreateHbaseHaSlbResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateHbaseHaSlbResponseBody(name='body'),
}
/**
* @param request CreateHbaseHaSlbRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateHbaseHaSlbResponse
*/
async function createHbaseHaSlbWithOptions(request: CreateHbaseHaSlbRequest, runtime: Util.RuntimeOptions): CreateHbaseHaSlbResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bdsId)) {
query['BdsId'] = request.bdsId;
}
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.haId)) {
query['HaId'] = request.haId;
}
if (!Util.isUnset(request.haTypes)) {
query['HaTypes'] = request.haTypes;
}
if (!Util.isUnset(request.hbaseType)) {
query['HbaseType'] = request.hbaseType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateHbaseHaSlb',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CreateHbaseHaSlbRequest
* @return CreateHbaseHaSlbResponse
*/
async function createHbaseHaSlb(request: CreateHbaseHaSlbRequest): CreateHbaseHaSlbResponse {
var runtime = new Util.RuntimeOptions{};
return createHbaseHaSlbWithOptions(request, runtime);
}
model CreateMultiZoneClusterRequest {
arbiterVSwitchId?: string(name='ArbiterVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxb*****'),
arbiterZoneId?: string(name='ArbiterZoneId', description='This parameter is required.', example='cn-hangzhou-b'),
archVersion?: string(name='ArchVersion', description='This parameter is required.', example='2.0'),
autoRenewPeriod?: int32(name='AutoRenewPeriod', example='0'),
clientToken?: string(name='ClientToken', example='dfh3sf5gslfksfk****'),
clusterName?: string(name='ClusterName', example='hbaseue_test'),
coreDiskSize?: int32(name='CoreDiskSize', description='This parameter is required.', example='400'),
coreDiskType?: string(name='CoreDiskType', description='This parameter is required.', example='cloud_ssd'),
coreInstanceType?: string(name='CoreInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
coreNodeCount?: int32(name='CoreNodeCount', description='This parameter is required.', example='4'),
engine?: string(name='Engine', description='This parameter is required.', example='hbaseue'),
engineVersion?: string(name='EngineVersion', description='This parameter is required.', example='2.0'),
logDiskSize?: int32(name='LogDiskSize', description='This parameter is required.', example='400'),
logDiskType?: string(name='LogDiskType', description='This parameter is required.', example='cloud_ssd'),
logInstanceType?: string(name='LogInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
logNodeCount?: int32(name='LogNodeCount', description='This parameter is required.', example='4'),
masterInstanceType?: string(name='MasterInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
multiZoneCombination?: string(name='MultiZoneCombination', description='This parameter is required.', example='cn-hangzhou-bef-aliyun-com'),
payType?: string(name='PayType', description='This parameter is required.', example='Postpaid'),
period?: int32(name='Period', example='1'),
periodUnit?: string(name='PeriodUnit', example='month'),
primaryVSwitchId?: string(name='PrimaryVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxe****'),
primaryZoneId?: string(name='PrimaryZoneId', description='This parameter is required.', example='cn-hangzhou-e'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
resourceGroupId?: string(name='ResourceGroupId', example='rg-gg3f4f5d5g5w****'),
securityIPList?: string(name='SecurityIPList', example='127.0.0.1'),
standbyVSwitchId?: string(name='StandbyVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxf****'),
standbyZoneId?: string(name='StandbyZoneId', description='This parameter is required.', example='cn-hangzhou-f'),
vpcId?: string(name='VpcId', description='This parameter is required.', example='vpc-bp120k6ixs4eog****'),
}
model CreateMultiZoneClusterResponseBody = {
clusterId?: string(name='ClusterId', example='ld-t4nn71xa0yn56****'),
orderId?: string(name='OrderId', example='23232453****'),
requestId?: string(name='RequestId', example='7F68E8F5-0377-4CF8-8B1D-FFFD6F5804D5'),
}
model CreateMultiZoneClusterResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateMultiZoneClusterResponseBody(name='body'),
}
/**
* @param request CreateMultiZoneClusterRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateMultiZoneClusterResponse
*/
async function createMultiZoneClusterWithOptions(request: CreateMultiZoneClusterRequest, runtime: Util.RuntimeOptions): CreateMultiZoneClusterResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.arbiterVSwitchId)) {
query['ArbiterVSwitchId'] = request.arbiterVSwitchId;
}
if (!Util.isUnset(request.arbiterZoneId)) {
query['ArbiterZoneId'] = request.arbiterZoneId;
}
if (!Util.isUnset(request.archVersion)) {
query['ArchVersion'] = request.archVersion;
}
if (!Util.isUnset(request.autoRenewPeriod)) {
query['AutoRenewPeriod'] = request.autoRenewPeriod;
}
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clusterName)) {
query['ClusterName'] = request.clusterName;
}
if (!Util.isUnset(request.coreDiskSize)) {
query['CoreDiskSize'] = request.coreDiskSize;
}
if (!Util.isUnset(request.coreDiskType)) {
query['CoreDiskType'] = request.coreDiskType;
}
if (!Util.isUnset(request.coreInstanceType)) {
query['CoreInstanceType'] = request.coreInstanceType;
}
if (!Util.isUnset(request.coreNodeCount)) {
query['CoreNodeCount'] = request.coreNodeCount;
}
if (!Util.isUnset(request.engine)) {
query['Engine'] = request.engine;
}
if (!Util.isUnset(request.engineVersion)) {
query['EngineVersion'] = request.engineVersion;
}
if (!Util.isUnset(request.logDiskSize)) {
query['LogDiskSize'] = request.logDiskSize;
}
if (!Util.isUnset(request.logDiskType)) {
query['LogDiskType'] = request.logDiskType;
}
if (!Util.isUnset(request.logInstanceType)) {
query['LogInstanceType'] = request.logInstanceType;
}
if (!Util.isUnset(request.logNodeCount)) {
query['LogNodeCount'] = request.logNodeCount;
}
if (!Util.isUnset(request.masterInstanceType)) {
query['MasterInstanceType'] = request.masterInstanceType;
}
if (!Util.isUnset(request.multiZoneCombination)) {
query['MultiZoneCombination'] = request.multiZoneCombination;
}
if (!Util.isUnset(request.payType)) {
query['PayType'] = request.payType;
}
if (!Util.isUnset(request.period)) {
query['Period'] = request.period;
}
if (!Util.isUnset(request.periodUnit)) {
query['PeriodUnit'] = request.periodUnit;
}
if (!Util.isUnset(request.primaryVSwitchId)) {
query['PrimaryVSwitchId'] = request.primaryVSwitchId;
}
if (!Util.isUnset(request.primaryZoneId)) {
query['PrimaryZoneId'] = request.primaryZoneId;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceGroupId)) {
query['ResourceGroupId'] = request.resourceGroupId;
}
if (!Util.isUnset(request.securityIPList)) {
query['SecurityIPList'] = request.securityIPList;
}
if (!Util.isUnset(request.standbyVSwitchId)) {
query['StandbyVSwitchId'] = request.standbyVSwitchId;
}
if (!Util.isUnset(request.standbyZoneId)) {
query['StandbyZoneId'] = request.standbyZoneId;
}
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateMultiZoneCluster',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CreateMultiZoneClusterRequest
* @return CreateMultiZoneClusterResponse
*/
async function createMultiZoneCluster(request: CreateMultiZoneClusterRequest): CreateMultiZoneClusterResponse {
var runtime = new Util.RuntimeOptions{};
return createMultiZoneClusterWithOptions(request, runtime);
}
model CreateRestorePlanRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
restoreAllTable?: boolean(name='RestoreAllTable', description='This parameter is required.', example='false'),
restoreByCopy?: boolean(name='RestoreByCopy', description='This parameter is required.', example='true'),
restoreToDate?: string(name='RestoreToDate', description='This parameter is required.', example='2020-11-05T05:49:42Z'),
tables?: string(name='Tables', example='test_ns:test_table/test_ns:test_table2'),
targetClusterId?: string(name='TargetClusterId', description='This parameter is required.', example='ld-bp169l540vc6c****'),
}
model CreateRestorePlanResponseBody = {
requestId?: string(name='RequestId', example='A0598673-EB6E-4F6D-9961-E0F2012090C0'),
}
model CreateRestorePlanResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateRestorePlanResponseBody(name='body'),
}
/**
* @param request CreateRestorePlanRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateRestorePlanResponse
*/
async function createRestorePlanWithOptions(request: CreateRestorePlanRequest, runtime: Util.RuntimeOptions): CreateRestorePlanResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.restoreAllTable)) {
query['RestoreAllTable'] = request.restoreAllTable;
}
if (!Util.isUnset(request.restoreByCopy)) {
query['RestoreByCopy'] = request.restoreByCopy;
}
if (!Util.isUnset(request.restoreToDate)) {
query['RestoreToDate'] = request.restoreToDate;
}
if (!Util.isUnset(request.tables)) {
query['Tables'] = request.tables;
}
if (!Util.isUnset(request.targetClusterId)) {
query['TargetClusterId'] = request.targetClusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateRestorePlan',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CreateRestorePlanRequest
* @return CreateRestorePlanResponse
*/
async function createRestorePlan(request: CreateRestorePlanRequest): CreateRestorePlanResponse {
var runtime = new Util.RuntimeOptions{};
return createRestorePlanWithOptions(request, runtime);
}
model CreateServerlessClusterRequest {
autoRenewPeriod?: int32(name='AutoRenewPeriod', example='2'),
clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
clientType?: string(name='ClientType', example='xx'),
clusterName?: string(name='ClusterName', example='serverless-name'),
diskType?: string(name='DiskType', example='cloud_ssd'),
engine?: string(name='Engine', example='serverlesshbase'),
engineVersion?: string(name='EngineVersion', example='2.0'),
payType?: string(name='PayType', description='This parameter is required.', example='Prepaid'),
period?: int32(name='Period', example='6'),
periodUnit?: string(name='PeriodUnit', example='month'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
resourceGroupId?: string(name='ResourceGroupId', example='rg-j4d53glb3****'),
serverlessCapability?: int32(name='ServerlessCapability', example='1000'),
serverlessSpec?: string(name='ServerlessSpec', example='serverless.small'),
serverlessStorage?: int32(name='ServerlessStorage', example='100'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp191ipotqj1ssyl*****'),
vpcId?: string(name='VpcId', example='vpc-bp120k6ixs4eog****'),
zoneId?: string(name='ZoneId', description='This parameter is required.', example='cn-hangzhou-f'),
}
model CreateServerlessClusterResponseBody = {
clusterId?: string(name='ClusterId', example='sh-bp1a969y7681****'),
orderId?: string(name='OrderId', example='23232453233*****'),
passWord?: string(name='PassWord', example='*********'),
requestId?: string(name='RequestId', example='3E19E345-101D-4014-946C-************'),
}
model CreateServerlessClusterResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateServerlessClusterResponseBody(name='body'),
}
/**
* @param request CreateServerlessClusterRequest
* @param runtime runtime options for this request RuntimeOptions
* @return CreateServerlessClusterResponse
*/
async function createServerlessClusterWithOptions(request: CreateServerlessClusterRequest, runtime: Util.RuntimeOptions): CreateServerlessClusterResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.autoRenewPeriod)) {
query['AutoRenewPeriod'] = request.autoRenewPeriod;
}
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clientType)) {
query['ClientType'] = request.clientType;
}
if (!Util.isUnset(request.clusterName)) {
query['ClusterName'] = request.clusterName;
}
if (!Util.isUnset(request.diskType)) {
query['DiskType'] = request.diskType;
}
if (!Util.isUnset(request.engine)) {
query['Engine'] = request.engine;
}
if (!Util.isUnset(request.engineVersion)) {
query['EngineVersion'] = request.engineVersion;
}
if (!Util.isUnset(request.payType)) {
query['PayType'] = request.payType;
}
if (!Util.isUnset(request.period)) {
query['Period'] = request.period;
}
if (!Util.isUnset(request.periodUnit)) {
query['PeriodUnit'] = request.periodUnit;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceGroupId)) {
query['ResourceGroupId'] = request.resourceGroupId;
}
if (!Util.isUnset(request.serverlessCapability)) {
query['ServerlessCapability'] = request.serverlessCapability;
}
if (!Util.isUnset(request.serverlessSpec)) {
query['ServerlessSpec'] = request.serverlessSpec;
}
if (!Util.isUnset(request.serverlessStorage)) {
query['ServerlessStorage'] = request.serverlessStorage;
}
if (!Util.isUnset(request.vSwitchId)) {
query['VSwitchId'] = request.vSwitchId;
}
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateServerlessCluster',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request CreateServerlessClusterRequest
* @return CreateServerlessClusterResponse
*/
async function createServerlessCluster(request: CreateServerlessClusterRequest): CreateServerlessClusterResponse {
var runtime = new Util.RuntimeOptions{};
return createServerlessClusterWithOptions(request, runtime);
}
model DeleteAccountRequest {
accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}
model DeleteAccountResponseBody = {
requestId?: string(name='RequestId', example='729CB2A7-3065-53A9-B27C-7033CA4881D9'),
}
model DeleteAccountResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteAccountResponseBody(name='body'),
}
/**
* @summary 删除账户
*
* @param request DeleteAccountRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteAccountResponse
*/
async function deleteAccountWithOptions(request: DeleteAccountRequest, runtime: Util.RuntimeOptions): DeleteAccountResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.accountName)) {
query['AccountName'] = request.accountName;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteAccount',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @summary 删除账户
*
* @param request DeleteAccountRequest
* @return DeleteAccountResponse
*/
async function deleteAccount(request: DeleteAccountRequest): DeleteAccountResponse {
var runtime = new Util.RuntimeOptions{};
return deleteAccountWithOptions(request, runtime);
}
model DeleteGlobalResourceRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
regionId?: string(name='RegionId'),
resourceName?: string(name='ResourceName', description='This parameter is required.', example='PubPhoenixSLBQueryServerVip'),
resourceType?: string(name='ResourceType', description='This parameter is required.', example='GLOBAL_VIP'),
}
model DeleteGlobalResourceResponseBody = {
requestId?: string(name='RequestId', example='BD0B0B9A-79E8-4FDD-9C51-93443490B784'),
}
model DeleteGlobalResourceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteGlobalResourceResponseBody(name='body'),
}
/**
* @param request DeleteGlobalResourceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteGlobalResourceResponse
*/
async function deleteGlobalResourceWithOptions(request: DeleteGlobalResourceRequest, runtime: Util.RuntimeOptions): DeleteGlobalResourceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceName)) {
query['ResourceName'] = request.resourceName;
}
if (!Util.isUnset(request.resourceType)) {
query['ResourceType'] = request.resourceType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteGlobalResource',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DeleteGlobalResourceRequest
* @return DeleteGlobalResourceResponse
*/
async function deleteGlobalResource(request: DeleteGlobalResourceRequest): DeleteGlobalResourceResponse {
var runtime = new Util.RuntimeOptions{};
return deleteGlobalResourceWithOptions(request, runtime);
}
model DeleteHBaseHaDBRequest {
bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-bp14112fd7g52s1****'),
haId?: string(name='HaId', description='This parameter is required.', example='ha-sw2o0l01s4r76****'),
}
model DeleteHBaseHaDBResponseBody = {
requestId?: string(name='RequestId', example='B409CF51-E01F-4551-BE40-123678FA9026'),
}
model DeleteHBaseHaDBResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteHBaseHaDBResponseBody(name='body'),
}
/**
* @param request DeleteHBaseHaDBRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteHBaseHaDBResponse
*/
async function deleteHBaseHaDBWithOptions(request: DeleteHBaseHaDBRequest, runtime: Util.RuntimeOptions): DeleteHBaseHaDBResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bdsId)) {
query['BdsId'] = request.bdsId;
}
if (!Util.isUnset(request.haId)) {
query['HaId'] = request.haId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteHBaseHaDB',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DeleteHBaseHaDBRequest
* @return DeleteHBaseHaDBResponse
*/
async function deleteHBaseHaDB(request: DeleteHBaseHaDBRequest): DeleteHBaseHaDBResponse {
var runtime = new Util.RuntimeOptions{};
return deleteHBaseHaDBWithOptions(request, runtime);
}
model DeleteHBaseSlbServerRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
slbServer?: string(name='SlbServer', description='This parameter is required.', example='thrift'),
}
model DeleteHBaseSlbServerResponseBody = {
requestId?: string(name='RequestId', example='7242130A-82CF-49BF-AB32-30DCB819EBA6'),
}
model DeleteHBaseSlbServerResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteHBaseSlbServerResponseBody(name='body'),
}
/**
* @param request DeleteHBaseSlbServerRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteHBaseSlbServerResponse
*/
async function deleteHBaseSlbServerWithOptions(request: DeleteHBaseSlbServerRequest, runtime: Util.RuntimeOptions): DeleteHBaseSlbServerResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.slbServer)) {
query['SlbServer'] = request.slbServer;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteHBaseSlbServer',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DeleteHBaseSlbServerRequest
* @return DeleteHBaseSlbServerResponse
*/
async function deleteHBaseSlbServer(request: DeleteHBaseSlbServerRequest): DeleteHBaseSlbServerResponse {
var runtime = new Util.RuntimeOptions{};
return deleteHBaseSlbServerWithOptions(request, runtime);
}
model DeleteHbaseHaSlbRequest {
bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-t4n3496whj23ia4k'),
haId?: string(name='HaId', description='This parameter is required.', example='ha-v21tmnxjwh2yuy1il'),
haTypes?: string(name='HaTypes', description='This parameter is required.', example='thrift'),
}
model DeleteHbaseHaSlbResponseBody = {
requestId?: string(name='RequestId', example='C9D568D9-A59C-4AF2-8FBB-F086A841D58E'),
}
model DeleteHbaseHaSlbResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteHbaseHaSlbResponseBody(name='body'),
}
/**
* @param request DeleteHbaseHaSlbRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteHbaseHaSlbResponse
*/
async function deleteHbaseHaSlbWithOptions(request: DeleteHbaseHaSlbRequest, runtime: Util.RuntimeOptions): DeleteHbaseHaSlbResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bdsId)) {
query['BdsId'] = request.bdsId;
}
if (!Util.isUnset(request.haId)) {
query['HaId'] = request.haId;
}
if (!Util.isUnset(request.haTypes)) {
query['HaTypes'] = request.haTypes;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteHbaseHaSlb',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DeleteHbaseHaSlbRequest
* @return DeleteHbaseHaSlbResponse
*/
async function deleteHbaseHaSlb(request: DeleteHbaseHaSlbRequest): DeleteHbaseHaSlbResponse {
var runtime = new Util.RuntimeOptions{};
return deleteHbaseHaSlbWithOptions(request, runtime);
}
model DeleteInstanceRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
immediateDeleteFlag?: boolean(name='ImmediateDeleteFlag', example='false'),
}
model DeleteInstanceResponseBody = {
requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}
model DeleteInstanceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteInstanceResponseBody(name='body'),
}
/**
* @param request DeleteInstanceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteInstanceResponse
*/
async function deleteInstanceWithOptions(request: DeleteInstanceRequest, runtime: Util.RuntimeOptions): DeleteInstanceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.immediateDeleteFlag)) {
query['ImmediateDeleteFlag'] = request.immediateDeleteFlag;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteInstance',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DeleteInstanceRequest
* @return DeleteInstanceResponse
*/
async function deleteInstance(request: DeleteInstanceRequest): DeleteInstanceResponse {
var runtime = new Util.RuntimeOptions{};
return deleteInstanceWithOptions(request, runtime);
}
model DeleteMultiZoneClusterRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='d-t4nn71xa0yn56****'),
immediateDeleteFlag?: boolean(name='ImmediateDeleteFlag', example='false'),
}
model DeleteMultiZoneClusterResponseBody = {
requestId?: string(name='RequestId', example='169A3910-A39E-4BC2-AA9F-E7AD8D473527'),
}
model DeleteMultiZoneClusterResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteMultiZoneClusterResponseBody(name='body'),
}
/**
* @param request DeleteMultiZoneClusterRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteMultiZoneClusterResponse
*/
async function deleteMultiZoneClusterWithOptions(request: DeleteMultiZoneClusterRequest, runtime: Util.RuntimeOptions): DeleteMultiZoneClusterResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.immediateDeleteFlag)) {
query['ImmediateDeleteFlag'] = request.immediateDeleteFlag;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteMultiZoneCluster',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DeleteMultiZoneClusterRequest
* @return DeleteMultiZoneClusterResponse
*/
async function deleteMultiZoneCluster(request: DeleteMultiZoneClusterRequest): DeleteMultiZoneClusterResponse {
var runtime = new Util.RuntimeOptions{};
return deleteMultiZoneClusterWithOptions(request, runtime);
}
model DeleteServerlessClusterRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='sh-bp1pj13wh9****'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-shenzhen'),
zoneId?: string(name='ZoneId', description='This parameter is required.', example='cn-shenzhen-e'),
}
model DeleteServerlessClusterResponseBody = {
requestId?: string(name='RequestId', example='46950E74-59C4-4E3E-9B38-A33B*********'),
}
model DeleteServerlessClusterResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteServerlessClusterResponseBody(name='body'),
}
/**
* @param request DeleteServerlessClusterRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteServerlessClusterResponse
*/
async function deleteServerlessClusterWithOptions(request: DeleteServerlessClusterRequest, runtime: Util.RuntimeOptions): DeleteServerlessClusterResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteServerlessCluster',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DeleteServerlessClusterRequest
* @return DeleteServerlessClusterResponse
*/
async function deleteServerlessCluster(request: DeleteServerlessClusterRequest): DeleteServerlessClusterResponse {
var runtime = new Util.RuntimeOptions{};
return deleteServerlessClusterWithOptions(request, runtime);
}
model DeleteUserHdfsInfoRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
nameService?: string(name='NameService', description='This parameter is required.', example='hdfs_test'),
}
model DeleteUserHdfsInfoResponseBody = {
requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}
model DeleteUserHdfsInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteUserHdfsInfoResponseBody(name='body'),
}
/**
* @param request DeleteUserHdfsInfoRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DeleteUserHdfsInfoResponse
*/
async function deleteUserHdfsInfoWithOptions(request: DeleteUserHdfsInfoRequest, runtime: Util.RuntimeOptions): DeleteUserHdfsInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.nameService)) {
query['NameService'] = request.nameService;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteUserHdfsInfo',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DeleteUserHdfsInfoRequest
* @return DeleteUserHdfsInfoResponse
*/
async function deleteUserHdfsInfo(request: DeleteUserHdfsInfoRequest): DeleteUserHdfsInfoResponse {
var runtime = new Util.RuntimeOptions{};
return deleteUserHdfsInfoWithOptions(request, runtime);
}
model DescribeAccountsRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp1uoihlf82e8****'),
}
model DescribeAccountsResponseBody = {
accounts?: {
account?: [ string ](name='account')
}(name='Accounts'),
requestId?: string(name='RequestId', example='F744E939-D08D-5623-82C8-9D1F9F7685D1'),
}
model DescribeAccountsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeAccountsResponseBody(name='body'),
}
/**
* @summary 查询账户列表
*
* @param request DescribeAccountsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeAccountsResponse
*/
async function describeAccountsWithOptions(request: DescribeAccountsRequest, runtime: Util.RuntimeOptions): DescribeAccountsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeAccounts',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @summary 查询账户列表
*
* @param request DescribeAccountsRequest
* @return DescribeAccountsResponse
*/
async function describeAccounts(request: DescribeAccountsRequest): DescribeAccountsResponse {
var runtime = new Util.RuntimeOptions{};
return describeAccountsWithOptions(request, runtime);
}
model DescribeActiveOperationTaskTypeRequest {
isHistory?: int32(name='IsHistory', example='0'),
ownerAccount?: string(name='OwnerAccount'),
ownerId?: long(name='OwnerId'),
resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
resourceOwnerId?: long(name='ResourceOwnerId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeActiveOperationTaskTypeResponseBody = {
requestId?: string(name='RequestId', example='EC7E27FC-58F8-4722-89CF-D1B6B0971956'),
typeList?: [
{
count?: int32(name='Count', example='1'),
taskType?: string(name='TaskType', example='rds_apsaradb_upgrade'),
taskTypeInfoEn?: string(name='TaskTypeInfoEn', example='rds_apsaradb_upgrade'),
taskTypeInfoZh?: string(name='TaskTypeInfoZh'),
}
](name='TypeList'),
}
model DescribeActiveOperationTaskTypeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeActiveOperationTaskTypeResponseBody(name='body'),
}
/**
* @param request DescribeActiveOperationTaskTypeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeActiveOperationTaskTypeResponse
*/
async function describeActiveOperationTaskTypeWithOptions(request: DescribeActiveOperationTaskTypeRequest, runtime: Util.RuntimeOptions): DescribeActiveOperationTaskTypeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.isHistory)) {
query['IsHistory'] = request.isHistory;
}
if (!Util.isUnset(request.ownerAccount)) {
query['OwnerAccount'] = request.ownerAccount;
}
if (!Util.isUnset(request.ownerId)) {
query['OwnerId'] = request.ownerId;
}
if (!Util.isUnset(request.resourceOwnerAccount)) {
query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
}
if (!Util.isUnset(request.resourceOwnerId)) {
query['ResourceOwnerId'] = request.resourceOwnerId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeActiveOperationTaskType',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeActiveOperationTaskTypeRequest
* @return DescribeActiveOperationTaskTypeResponse
*/
async function describeActiveOperationTaskType(request: DescribeActiveOperationTaskTypeRequest): DescribeActiveOperationTaskTypeResponse {
var runtime = new Util.RuntimeOptions{};
return describeActiveOperationTaskTypeWithOptions(request, runtime);
}
model DescribeActiveOperationTasksRequest {
allowCancel?: int32(name='AllowCancel', example='1'),
allowChange?: int32(name='AllowChange', example='1'),
changeLevel?: string(name='ChangeLevel', example='S1'),
dbType?: string(name='DbType', example='hbaseue'),
insName?: string(name='InsName', example='ld-bp150tns0sjxs****'),
ownerAccount?: string(name='OwnerAccount'),
ownerId?: long(name='OwnerId'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='30'),
productId?: string(name='ProductId', example='hbase'),
region?: string(name='Region', example='cn-hangzhou'),
resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
resourceOwnerId?: long(name='ResourceOwnerId'),
securityToken?: string(name='SecurityToken'),
status?: int32(name='Status', example='5'),
taskType?: string(name='TaskType', example='rds_apsaradb_upgrade'),
}
model DescribeActiveOperationTasksResponseBody = {
items?: [
{
allowCancel?: string(name='AllowCancel', example='1'),
allowChange?: string(name='AllowChange', example='1'),
changeLevel?: string(name='ChangeLevel', example='all'),
changeLevelEn?: string(name='ChangeLevelEn', example='Risk repairment'),
changeLevelZh?: string(name='ChangeLevelZh'),
createdTime?: string(name='CreatedTime', example='2022-02-15 23:59:59'),
currentAVZ?: string(name='CurrentAVZ', example='cn-shanghai-et-a'),
dbType?: string(name='DbType', example='hbaseue'),
dbVersion?: string(name='DbVersion', example='2.0'),
deadline?: string(name='Deadline', example='2022-02-19 23:59:59'),
id?: int32(name='Id', example='111111'),
impactEn?: string(name='ImpactEn', example='Transient instance disconnection'),
impactZh?: string(name='ImpactZh'),
insComment?: string(name='InsComment', example='--'),
insName?: string(name='InsName', example='ld-bp150tns0sjxs****'),
modifiedTime?: string(name='ModifiedTime', example='2022-02-19 14:00:00'),
prepareInterval?: string(name='PrepareInterval', example='14:00:00'),
region?: string(name='Region', example='cn-hanghzou'),
resultInfo?: string(name='ResultInfo', example='--'),
startTime?: string(name='StartTime', example='2022-02-19 10:00:00'),
status?: int32(name='Status', example='5'),
subInsNames?: [ string ](name='SubInsNames'),
switchTime?: string(name='SwitchTime', example='2022-02-19 14:00:00'),
taskType?: string(name='TaskType', example='rds_apsaradb_upgrade'),
taskTypeEn?: string(name='TaskTypeEn', example='rds_apsaradb_upgrade'),
taskTypeZh?: string(name='TaskTypeZh'),
}
](name='Items'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='30'),
requestId?: string(name='RequestId', example='C634E813-42FA-53D2-A7EB-B881C4B264CC'),
totalRecordCount?: int32(name='TotalRecordCount', example='1'),
}
model DescribeActiveOperationTasksResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeActiveOperationTasksResponseBody(name='body'),
}
/**
* @param request DescribeActiveOperationTasksRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeActiveOperationTasksResponse
*/
async function describeActiveOperationTasksWithOptions(request: DescribeActiveOperationTasksRequest, runtime: Util.RuntimeOptions): DescribeActiveOperationTasksResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.allowCancel)) {
query['AllowCancel'] = request.allowCancel;
}
if (!Util.isUnset(request.allowChange)) {
query['AllowChange'] = request.allowChange;
}
if (!Util.isUnset(request.changeLevel)) {
query['ChangeLevel'] = request.changeLevel;
}
if (!Util.isUnset(request.dbType)) {
query['DbType'] = request.dbType;
}
if (!Util.isUnset(request.insName)) {
query['InsName'] = request.insName;
}
if (!Util.isUnset(request.ownerAccount)) {
query['OwnerAccount'] = request.ownerAccount;
}
if (!Util.isUnset(request.ownerId)) {
query['OwnerId'] = request.ownerId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.productId)) {
query['ProductId'] = request.productId;
}
if (!Util.isUnset(request.region)) {
query['Region'] = request.region;
}
if (!Util.isUnset(request.resourceOwnerAccount)) {
query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
}
if (!Util.isUnset(request.resourceOwnerId)) {
query['ResourceOwnerId'] = request.resourceOwnerId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.status)) {
query['Status'] = request.status;
}
if (!Util.isUnset(request.taskType)) {
query['TaskType'] = request.taskType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeActiveOperationTasks',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeActiveOperationTasksRequest
* @return DescribeActiveOperationTasksResponse
*/
async function describeActiveOperationTasks(request: DescribeActiveOperationTasksRequest): DescribeActiveOperationTasksResponse {
var runtime = new Util.RuntimeOptions{};
return describeActiveOperationTasksWithOptions(request, runtime);
}
model DescribeAvailableResourceRequest {
chargeType?: string(name='ChargeType', description='This parameter is required.', example='Prepaid'),
coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.large'),
diskType?: string(name='DiskType', example='cloud_ssd'),
engine?: string(name='Engine', example='hbaseue'),
engineVersion?: string(name='EngineVersion', example='2.0'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
zoneId?: string(name='ZoneId', example='cn-hangzhou-h'),
}
model DescribeAvailableResourceResponseBody = {
availableZones?: {
availableZone?: [
{
masterResources?: {
masterResource?: [
{
instanceType?: string(name='InstanceType', example='hbase.sn1.medium'),
instanceTypeDetail?: {
cpu?: int32(name='Cpu', example='4'),
mem?: int32(name='Mem', example='8'),
}(name='InstanceTypeDetail'),
}
](name='MasterResource')
}(name='MasterResources'),
regionId?: string(name='RegionId', example='cn-shenzhen'),
supportedEngines?: {
supportedEngine?: [
{
engine?: string(name='Engine', example='hbase'),
supportedEngineVersions?: {
supportedEngineVersion?: [
{
supportedCategories?: {
supportedCategories?: [
{
category?: string(name='Category', example='cluster'),
supportedStorageTypes?: {
supportedStorageType?: [
{
coreResources?: {
coreResource?: [
{
DBInstanceStorageRange?: {
maxSize?: int32(name='MaxSize', example='8000'),
minSize?: int32(name='MinSize', example='400'),
stepSize?: int32(name='StepSize', example='40'),
}(name='DBInstanceStorageRange'),
instanceType?: string(name='InstanceType', example='hbase.sn1.large'),
instanceTypeDetail?: {
cpu?: int32(name='Cpu', example='4'),
mem?: int32(name='Mem', example='8'),
}(name='InstanceTypeDetail'),
maxCoreCount?: int32(name='MaxCoreCount', example='16'),
}
](name='CoreResource')
}(name='CoreResources'),
storageType?: string(name='StorageType', example='cloud_ssd'),
}
](name='SupportedStorageType')
}(name='SupportedStorageTypes'),
}
](name='SupportedCategories')
}(name='SupportedCategories'),
version?: string(name='Version', example='2.0'),
}
](name='SupportedEngineVersion')
}(name='SupportedEngineVersions'),
}
](name='SupportedEngine')
}(name='SupportedEngines'),
zoneId?: string(name='ZoneId', example='cn-shenzhen-e'),
}
](name='AvailableZone')
}(name='AvailableZones'),
requestId?: string(name='RequestId', example='EA76F208-E334-592A-A0C6-41E15EC87ED0'),
}
model DescribeAvailableResourceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeAvailableResourceResponseBody(name='body'),
}
/**
* @param request DescribeAvailableResourceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeAvailableResourceResponse
*/
async function describeAvailableResourceWithOptions(request: DescribeAvailableResourceRequest, runtime: Util.RuntimeOptions): DescribeAvailableResourceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.chargeType)) {
query['ChargeType'] = request.chargeType;
}
if (!Util.isUnset(request.coreInstanceType)) {
query['CoreInstanceType'] = request.coreInstanceType;
}
if (!Util.isUnset(request.diskType)) {
query['DiskType'] = request.diskType;
}
if (!Util.isUnset(request.engine)) {
query['Engine'] = request.engine;
}
if (!Util.isUnset(request.engineVersion)) {
query['EngineVersion'] = request.engineVersion;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeAvailableResource',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeAvailableResourceRequest
* @return DescribeAvailableResourceResponse
*/
async function describeAvailableResource(request: DescribeAvailableResourceRequest): DescribeAvailableResourceResponse {
var runtime = new Util.RuntimeOptions{};
return describeAvailableResourceWithOptions(request, runtime);
}
model DescribeBackupPlanConfigRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
}
model DescribeBackupPlanConfigResponseBody = {
fullBackupCycle?: int32(name='FullBackupCycle', example='7'),
minHFileBackupCount?: int32(name='MinHFileBackupCount', example='3'),
nextFullBackupDate?: string(name='NextFullBackupDate', example='2020-11-09T18:00:00Z'),
requestId?: string(name='RequestId', example='33A23201-6038-4A6A-B76A-61047EA04E6A'),
tables?: {
table?: [ string ](name='Table')
}(name='Tables'),
}
model DescribeBackupPlanConfigResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeBackupPlanConfigResponseBody(name='body'),
}
/**
* @param request DescribeBackupPlanConfigRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeBackupPlanConfigResponse
*/
async function describeBackupPlanConfigWithOptions(request: DescribeBackupPlanConfigRequest, runtime: Util.RuntimeOptions): DescribeBackupPlanConfigResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeBackupPlanConfig',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeBackupPlanConfigRequest
* @return DescribeBackupPlanConfigResponse
*/
async function describeBackupPlanConfig(request: DescribeBackupPlanConfigRequest): DescribeBackupPlanConfigResponse {
var runtime = new Util.RuntimeOptions{};
return describeBackupPlanConfigWithOptions(request, runtime);
}
model DescribeBackupPolicyRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
}
model DescribeBackupPolicyResponseBody = {
backupRetentionPeriod?: string(name='BackupRetentionPeriod', example='10'),
preferredBackupEndTimeUTC?: string(name='PreferredBackupEndTimeUTC', example='18:00Z'),
preferredBackupPeriod?: string(name='PreferredBackupPeriod', example='Friday'),
preferredBackupStartTimeUTC?: string(name='PreferredBackupStartTimeUTC', example='17:00Z'),
preferredBackupTime?: string(name='PreferredBackupTime', example='01:00-02:00'),
requestId?: string(name='RequestId', example='94AC38B6-7C6D-45B2-BC03-B8750071A482'),
}
model DescribeBackupPolicyResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeBackupPolicyResponseBody(name='body'),
}
/**
* @param request DescribeBackupPolicyRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeBackupPolicyResponse
*/
async function describeBackupPolicyWithOptions(request: DescribeBackupPolicyRequest, runtime: Util.RuntimeOptions): DescribeBackupPolicyResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeBackupPolicy',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeBackupPolicyRequest
* @return DescribeBackupPolicyResponse
*/
async function describeBackupPolicy(request: DescribeBackupPolicyRequest): DescribeBackupPolicyResponse {
var runtime = new Util.RuntimeOptions{};
return describeBackupPolicyWithOptions(request, runtime);
}
model DescribeBackupStatusRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
}
model DescribeBackupStatusResponseBody = {
backupStatus?: string(name='BackupStatus', example='opened'),
bdsClusterId?: string(name='BdsClusterId', example='bds-m5e54q06ceyhxxxx'),
clusterId?: string(name='ClusterId', example='ld-m5eznlga4k5bcxxxx'),
requestId?: string(name='RequestId', example='F7E71430-A825-470A-B40B-DF3F3AAC9BEE'),
}
model DescribeBackupStatusResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeBackupStatusResponseBody(name='body'),
}
/**
* @param request DescribeBackupStatusRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeBackupStatusResponse
*/
async function describeBackupStatusWithOptions(request: DescribeBackupStatusRequest, runtime: Util.RuntimeOptions): DescribeBackupStatusResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeBackupStatus',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeBackupStatusRequest
* @return DescribeBackupStatusResponse
*/
async function describeBackupStatus(request: DescribeBackupStatusRequest): DescribeBackupStatusResponse {
var runtime = new Util.RuntimeOptions{};
return describeBackupStatusWithOptions(request, runtime);
}
model DescribeBackupSummaryRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp169l540vc6c****'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
}
model DescribeBackupSummaryResponseBody = {
full?: {
hasMore?: string(name='HasMore', example='false'),
nextFullBackupDate?: string(name='NextFullBackupDate', example='2020-11-09T18:00:00Z'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
records?: {
record?: [
{
createTime?: string(name='CreateTime', example='2020-11-02T18:00:00Z'),
dataSize?: string(name='DataSize', example='1.2 kB'),
finishTime?: string(name='FinishTime', example='2020-11-02T18:02:04Z'),
process?: string(name='Process', example='1/1'),
recordId?: string(name='RecordId', example='20201103020000'),
speed?: string(name='Speed', example='0.00 MB/s'),
status?: string(name='Status', example='SUCCESS'),
}
](name='Record')
}(name='Records'),
total?: int32(name='Total', example='2'),
}(name='Full'),
incr?: {
backupLogSize?: string(name='BackupLogSize', example='266 B'),
pos?: string(name='Pos', example='2020-11-05T01:20:31Z'),
queueLogNum?: string(name='QueueLogNum', example='0'),
runningLogNum?: string(name='RunningLogNum', example='2'),
speed?: string(name='Speed', example='0.00 MB/s'),
status?: string(name='Status', example='RUNNING'),
}(name='Incr'),
requestId?: string(name='RequestId', example='168793CB-7B31-43E7-ADAB-FE3E8D584D6E'),
}
model DescribeBackupSummaryResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeBackupSummaryResponseBody(name='body'),
}
/**
* @param request DescribeBackupSummaryRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeBackupSummaryResponse
*/
async function describeBackupSummaryWithOptions(request: DescribeBackupSummaryRequest, runtime: Util.RuntimeOptions): DescribeBackupSummaryResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeBackupSummary',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeBackupSummaryRequest
* @return DescribeBackupSummaryResponse
*/
async function describeBackupSummary(request: DescribeBackupSummaryRequest): DescribeBackupSummaryResponse {
var runtime = new Util.RuntimeOptions{};
return describeBackupSummaryWithOptions(request, runtime);
}
model DescribeBackupTablesRequest {
backupRecordId?: string(name='BackupRecordId', description='This parameter is required.', example='2020110302xxxx'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
}
model DescribeBackupTablesResponseBody = {
backupRecords?: {
backupRecord?: [
{
dataSize?: string(name='DataSize', example='1.2 kB'),
endTime?: string(name='EndTime', example='2020-11-02T18:00:05Z'),
message?: string(name='Message', example='null'),
process?: string(name='Process', example='14/14'),
speed?: string(name='Speed', example='0.00 MB/s'),
startTime?: string(name='StartTime', example='2020-11-02T18:00:00Z'),
state?: string(name='State', example='SUCCEEDED'),
table?: string(name='Table', example='default:test1'),
}
](name='BackupRecord')
}(name='BackupRecords'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='01262E9C-B0CC-4663-82FA-D50173649F92'),
tables?: {
table?: [ string ](name='Table')
}(name='Tables'),
total?: long(name='Total', example='1'),
}
model DescribeBackupTablesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeBackupTablesResponseBody(name='body'),
}
/**
* @param request DescribeBackupTablesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeBackupTablesResponse
*/
async function describeBackupTablesWithOptions(request: DescribeBackupTablesRequest, runtime: Util.RuntimeOptions): DescribeBackupTablesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.backupRecordId)) {
query['BackupRecordId'] = request.backupRecordId;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeBackupTables',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeBackupTablesRequest
* @return DescribeBackupTablesResponse
*/
async function describeBackupTables(request: DescribeBackupTablesRequest): DescribeBackupTablesResponse {
var runtime = new Util.RuntimeOptions{};
return describeBackupTablesWithOptions(request, runtime);
}
model DescribeBackupsRequest {
backupId?: string(name='BackupId', example='job-xxxx'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
endTime?: string(name='EndTime', example='2020-12-23 23:59:59'),
endTimeUTC?: string(name='EndTimeUTC', example='2020-12-23T15:59:59Z'),
pageNumber?: string(name='PageNumber', example='1'),
pageSize?: string(name='PageSize', example='10'),
startTime?: string(name='StartTime', example='2020-12-13 00:00:00'),
startTimeUTC?: string(name='StartTimeUTC', example='2020-12-12T16:00:00Z'),
}
model DescribeBackupsResponseBody = {
backups?: {
backup?: [
{
backupDBNames?: string(name='BackupDBNames', example='1'),
backupDownloadURL?: string(name='BackupDownloadURL', example='1'),
backupEndTime?: string(name='BackupEndTime', example='2020-12-23 17:25:24'),
backupEndTimeUTC?: string(name='BackupEndTimeUTC', example='2020-12-23T09:25:24Z'),
backupId?: int32(name='BackupId', example='511876087'),
backupMethod?: string(name='BackupMethod', example='P'),
backupMode?: string(name='BackupMode', example='0'),
backupSize?: string(name='BackupSize', example='0.00'),
backupStartTime?: string(name='BackupStartTime', example='2020-12-23 17:25:08'),
backupStartTimeUTC?: string(name='BackupStartTimeUTC', example='2020-12-23T09:25:08Z'),
backupStatus?: string(name='BackupStatus', example='0'),
backupType?: string(name='BackupType', example='F'),
}
](name='Backup')
}(name='Backups'),
enableStatus?: string(name='EnableStatus', example='enable'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='A93CE373-0FDE-4CCB-9DBA-6700906825ED'),
totalCount?: int32(name='TotalCount', example='1'),
}
model DescribeBackupsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeBackupsResponseBody(name='body'),
}
/**
* @param request DescribeBackupsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeBackupsResponse
*/
async function describeBackupsWithOptions(request: DescribeBackupsRequest, runtime: Util.RuntimeOptions): DescribeBackupsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.backupId)) {
query['BackupId'] = request.backupId;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.endTime)) {
query['EndTime'] = request.endTime;
}
if (!Util.isUnset(request.endTimeUTC)) {
query['EndTimeUTC'] = request.endTimeUTC;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.startTime)) {
query['StartTime'] = request.startTime;
}
if (!Util.isUnset(request.startTimeUTC)) {
query['StartTimeUTC'] = request.startTimeUTC;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeBackups',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeBackupsRequest
* @return DescribeBackupsResponse
*/
async function describeBackups(request: DescribeBackupsRequest): DescribeBackupsResponse {
var runtime = new Util.RuntimeOptions{};
return describeBackupsWithOptions(request, runtime);
}
model DescribeClusterConnectionRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
}
model DescribeClusterConnectionResponseBody = {
dbType?: string(name='DbType', example='hbaseue'),
isMultimod?: string(name='IsMultimod', example='true'),
netType?: string(name='NetType', example='VPC'),
requestId?: string(name='RequestId', example='70220050-A465-5DCC-8C0C-C38C6E3DB24D'),
serviceConnAddrs?: {
serviceConnAddr?: [
{
connAddrInfo?: {
connAddr?: string(name='ConnAddr', example='hb-****-proxy-phoenix.hbase.rds.aliyuncs.com'),
connAddrPort?: string(name='ConnAddrPort', example='8765'),
netType?: string(name='NetType', example='2'),
}(name='ConnAddrInfo'),
connType?: string(name='ConnType', example='PhoenixConnAddr'),
}
](name='ServiceConnAddr')
}(name='ServiceConnAddrs'),
slbConnAddrs?: {
slbConnAddr?: [
{
connAddrInfo?: {
connAddr?: string(name='ConnAddr', example='ld-bp150tns0sjxs****-proxy-hbaseue-pub.hbaseue.rds.aliyuncs.com'),
connAddrPort?: string(name='ConnAddrPort', example='9190'),
netType?: string(name='NetType', example='0'),
}(name='ConnAddrInfo'),
slbType?: string(name='SlbType', example='hbaseue'),
}
](name='SlbConnAddr')
}(name='SlbConnAddrs'),
thriftConn?: {
connAddr?: string(name='ConnAddr', example='hb-bp1u0639js2h7****-proxy-thrift.hbase.rds.aliyuncs.com'),
connAddrPort?: string(name='ConnAddrPort', example='9099'),
netType?: string(name='NetType', example='2'),
}(name='ThriftConn'),
uiProxyConnAddrInfo?: {
connAddr?: string(name='ConnAddr', example='ld-bp150tns0sjxs****-master1-001.hbaseue.rds.aliyuncs.com'),
connAddrPort?: string(name='ConnAddrPort', example='443'),
netType?: string(name='NetType', example='PUBLIC'),
}(name='UiProxyConnAddrInfo'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp1foll427ze3d4ps****'),
vpcId?: string(name='VpcId', example='vpc-bp15s22y1a7sff5gj****'),
zkConnAddrs?: {
zkConnAddr?: [
{
connAddr?: string(name='ConnAddr', example='ld-bp150tns0sjxs****-master1-001.hbaseue.rds.aliyuncs.com'),
connAddrPort?: string(name='ConnAddrPort', example='2181'),
netType?: string(name='NetType', example='2'),
}
](name='ZkConnAddr')
}(name='ZkConnAddrs'),
}
model DescribeClusterConnectionResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeClusterConnectionResponseBody(name='body'),
}
/**
* @param request DescribeClusterConnectionRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeClusterConnectionResponse
*/
async function describeClusterConnectionWithOptions(request: DescribeClusterConnectionRequest, runtime: Util.RuntimeOptions): DescribeClusterConnectionResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeClusterConnection',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeClusterConnectionRequest
* @return DescribeClusterConnectionResponse
*/
async function describeClusterConnection(request: DescribeClusterConnectionRequest): DescribeClusterConnectionResponse {
var runtime = new Util.RuntimeOptions{};
return describeClusterConnectionWithOptions(request, runtime);
}
model DescribeColdStorageRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp1uoihlf82e8****'),
}
model DescribeColdStorageResponseBody = {
clusterId?: string(name='ClusterId', example='ld-bp1uoihlf82e8****'),
coldStorageSize?: string(name='ColdStorageSize', example='800'),
coldStorageType?: string(name='ColdStorageType', example='BdsColdStorage'),
coldStorageUseAmount?: string(name='ColdStorageUseAmount', example='20.00'),
coldStorageUsePercent?: string(name='ColdStorageUsePercent', example='20.00'),
openStatus?: string(name='OpenStatus', example='open'),
payType?: string(name='PayType', example='POSTPAY'),
requestId?: string(name='RequestId', example='DCB9479E-F05F-4D1C-AFB7-C639B87764B7'),
}
model DescribeColdStorageResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeColdStorageResponseBody(name='body'),
}
/**
* @param request DescribeColdStorageRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeColdStorageResponse
*/
async function describeColdStorageWithOptions(request: DescribeColdStorageRequest, runtime: Util.RuntimeOptions): DescribeColdStorageResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeColdStorage',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeColdStorageRequest
* @return DescribeColdStorageResponse
*/
async function describeColdStorage(request: DescribeColdStorageRequest): DescribeColdStorageResponse {
var runtime = new Util.RuntimeOptions{};
return describeColdStorageWithOptions(request, runtime);
}
model DescribeDBInstanceUsageRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp1u0639js2h7****'),
}
model DescribeDBInstanceUsageResponseBody = {
requestId?: string(name='RequestId', example='A2D841CE-D066-53E8-B9AC-3731DCC85397'),
result?: string(name='Result', example='{\\\\"disk_usage_record\\\\":{\\\\"disk_used\\\\":\\\\"0.9GB\\\\",\\\\"disk_total\\\\":\\\\"1156.1GB\\\\",\\\\"usage_rate\\\\":\\\\"1%\\\\"}}'),
}
model DescribeDBInstanceUsageResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeDBInstanceUsageResponseBody(name='body'),
}
/**
* @param request DescribeDBInstanceUsageRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeDBInstanceUsageResponse
*/
async function describeDBInstanceUsageWithOptions(request: DescribeDBInstanceUsageRequest, runtime: Util.RuntimeOptions): DescribeDBInstanceUsageResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeDBInstanceUsage',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeDBInstanceUsageRequest
* @return DescribeDBInstanceUsageResponse
*/
async function describeDBInstanceUsage(request: DescribeDBInstanceUsageRequest): DescribeDBInstanceUsageResponse {
var runtime = new Util.RuntimeOptions{};
return describeDBInstanceUsageWithOptions(request, runtime);
}
model DescribeDeletedInstancesRequest {
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
}
model DescribeDeletedInstancesResponseBody = {
instances?: {
instance?: [
{
clusterType?: string(name='ClusterType', example='cluster'),
createdTime?: string(name='CreatedTime', example='2020-11-02T07:16:07Z'),
deleteTime?: string(name='DeleteTime', example='2020-11-02T07:27:24Z'),
engine?: string(name='Engine', example='hbase'),
instanceId?: string(name='InstanceId', example='hb-bp10q7n2zdw12xxxx'),
instanceName?: string(name='InstanceName', example='e2e-test'),
majorVersion?: string(name='MajorVersion', example='2.0'),
moduleStackVersion?: string(name='ModuleStackVersion', example='null'),
parentId?: string(name='ParentId', example='null'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
status?: string(name='Status', example='DELETED'),
zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}
](name='Instance')
}(name='Instances'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='0CAC5702-C862-44C0-AD54-C9CE70F4B246'),
totalCount?: long(name='TotalCount', example='1'),
}
model DescribeDeletedInstancesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeDeletedInstancesResponseBody(name='body'),
}
/**
* @param request DescribeDeletedInstancesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeDeletedInstancesResponse
*/
async function describeDeletedInstancesWithOptions(request: DescribeDeletedInstancesRequest, runtime: Util.RuntimeOptions): DescribeDeletedInstancesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeDeletedInstances',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeDeletedInstancesRequest
* @return DescribeDeletedInstancesResponse
*/
async function describeDeletedInstances(request: DescribeDeletedInstancesRequest): DescribeDeletedInstancesResponse {
var runtime = new Util.RuntimeOptions{};
return describeDeletedInstancesWithOptions(request, runtime);
}
model DescribeDiskWarningLineRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp1bl7iqzkahmyxxxx'),
}
model DescribeDiskWarningLineResponseBody = {
requestId?: string(name='RequestId', example='08DF8283-D290-4107-931E-7913D6D3480D'),
warningLine?: string(name='WarningLine', example='80'),
}
model DescribeDiskWarningLineResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeDiskWarningLineResponseBody(name='body'),
}
/**
* @param request DescribeDiskWarningLineRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeDiskWarningLineResponse
*/
async function describeDiskWarningLineWithOptions(request: DescribeDiskWarningLineRequest, runtime: Util.RuntimeOptions): DescribeDiskWarningLineResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeDiskWarningLine',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeDiskWarningLineRequest
* @return DescribeDiskWarningLineResponse
*/
async function describeDiskWarningLine(request: DescribeDiskWarningLineRequest): DescribeDiskWarningLineResponse {
var runtime = new Util.RuntimeOptions{};
return describeDiskWarningLineWithOptions(request, runtime);
}
model DescribeEndpointsRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}
model DescribeEndpointsResponseBody = {
connAddrs?: {
connAddrInfo?: [
{
connAddr?: string(name='ConnAddr', example='****'),
connAddrPort?: string(name='ConnAddrPort', example='****'),
connType?: string(name='ConnType', example='zkConn'),
netType?: string(name='NetType', example='2'),
}
](name='ConnAddrInfo')
}(name='ConnAddrs'),
engine?: string(name='Engine', example='hbaseue'),
netType?: string(name='NetType', example='VPC'),
requestId?: string(name='RequestId', example='F072593C-5234-5B56-9F63-3C7A3AD85D66'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp1foll427ze3d4ps****'),
vpcId?: string(name='VpcId', example='vpc-bp15s22y1a7sff5gj****'),
}
model DescribeEndpointsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeEndpointsResponseBody(name='body'),
}
/**
* @param request DescribeEndpointsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeEndpointsResponse
*/
async function describeEndpointsWithOptions(request: DescribeEndpointsRequest, runtime: Util.RuntimeOptions): DescribeEndpointsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeEndpoints',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeEndpointsRequest
* @return DescribeEndpointsResponse
*/
async function describeEndpoints(request: DescribeEndpointsRequest): DescribeEndpointsResponse {
var runtime = new Util.RuntimeOptions{};
return describeEndpointsWithOptions(request, runtime);
}
model DescribeInstanceRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}
model DescribeInstanceResponseBody = {
autoRenewal?: boolean(name='AutoRenewal', example='false'),
backupStatus?: string(name='BackupStatus', example='open'),
clusterId?: string(name='ClusterId', example='ld-bp150tns0sjxs****'),
clusterName?: string(name='ClusterName', example='testhbase'),
clusterType?: string(name='ClusterType', example='cluster'),
coldStorageSize?: int32(name='ColdStorageSize', example='800'),
coldStorageStatus?: string(name='ColdStorageStatus', example='open'),
confirmMaintainTime?: string(name='ConfirmMaintainTime', example='true'),
coreDiskCount?: string(name='CoreDiskCount', example='4'),
coreDiskSize?: int32(name='CoreDiskSize', example='100'),
coreDiskType?: string(name='CoreDiskType', example='cloud_ssd'),
coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn2.2xlarge'),
coreNodeCount?: int32(name='CoreNodeCount', example='2'),
createdTime?: string(name='CreatedTime', example='2021-07-19T11:23:22'),
createdTimeUTC?: string(name='CreatedTimeUTC', example='2021-07-19T03:23:22Z'),
duration?: int32(name='Duration', example='12'),
enableHbaseProxy?: boolean(name='EnableHbaseProxy', description='This parameter is required.', example='false'),
encryptionKey?: string(name='EncryptionKey', example='0d2470df-da7b-4786-b981-9a164dae****'),
encryptionType?: string(name='EncryptionType', example='NoEncryption'),
engine?: string(name='Engine', example='hbaseue'),
expireTime?: string(name='ExpireTime', example='2022-02-24T00:00:00'),
expireTimeUTC?: string(name='ExpireTimeUTC', example='2022-02-23T16:00:00Z'),
instanceId?: string(name='InstanceId', example='ld-bp150tns0sjxs****'),
instanceName?: string(name='InstanceName', example='testhbase'),
isDeletionProtection?: boolean(name='IsDeletionProtection', example='false'),
isHa?: boolean(name='IsHa', example='true'),
isLatestVersion?: boolean(name='IsLatestVersion', example='true'),
isMultiModel?: boolean(name='IsMultiModel', example='true'),
lproxyMinorVersion?: string(name='LproxyMinorVersion', example='2.3.2'),
maintainEndTime?: string(name='MaintainEndTime', example='22:00Z'),
maintainStartTime?: string(name='MaintainStartTime', example='18:00Z'),
majorVersion?: string(name='MajorVersion', example='2.0'),
masterDiskSize?: int32(name='MasterDiskSize', example='0'),
masterDiskType?: string(name='MasterDiskType', example='cloud_efficiency'),
masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn2.large'),
masterNodeCount?: int32(name='MasterNodeCount', example='2'),
minorVersion?: string(name='MinorVersion', example='2.2.9.1'),
moduleId?: int32(name='ModuleId', example='0'),
moduleStackVersion?: string(name='ModuleStackVersion', example='phoenxi:4.0'),
needUpgrade?: boolean(name='NeedUpgrade', example='false'),
needUpgradeComps?: {
comps?: [ string ](name='Comps')
}(name='NeedUpgradeComps'),
networkType?: string(name='NetworkType', example='VPC'),
parentId?: string(name='ParentId', example='ld-uf699153o1m2l****'),
payType?: string(name='PayType', example='Prepaid'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
requestId?: string(name='RequestId', example='3F429923-B6F6-52C5-9C2A-5B8A8C6BBA66'),
resourceGroupId?: string(name='ResourceGroupId', example='rg-acfmyiu4ekp****'),
status?: string(name='Status', example='ACTIVATION'),
tags?: {
tag?: [
{
key?: string(name='Key', example='test_key'),
value?: string(name='Value', example='test_value'),
}
](name='Tag')
}(name='Tags'),
taskProgress?: string(name='TaskProgress', example='25.00'),
taskStatus?: string(name='TaskStatus'),
vpcId?: string(name='VpcId', example='vpc-bp15s22y1a7sff5gj****'),
vswitchId?: string(name='VswitchId', example='vsw-bp1foll427ze3d4ps****'),
zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}
model DescribeInstanceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeInstanceResponseBody(name='body'),
}
/**
* @param request DescribeInstanceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeInstanceResponse
*/
async function describeInstanceWithOptions(request: DescribeInstanceRequest, runtime: Util.RuntimeOptions): DescribeInstanceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeInstance',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeInstanceRequest
* @return DescribeInstanceResponse
*/
async function describeInstance(request: DescribeInstanceRequest): DescribeInstanceResponse {
var runtime = new Util.RuntimeOptions{};
return describeInstanceWithOptions(request, runtime);
}
model DescribeInstanceTypeRequest {
instanceType?: string(name='InstanceType', example='hbase.n2.4xlarge'),
}
model DescribeInstanceTypeResponseBody = {
instanceTypeSpecList?: {
instanceTypeSpec?: [
{
cpuSize?: long(name='CpuSize', example='8'),
instanceType?: string(name='InstanceType', example='hbase.n2.4xlarge'),
memSize?: long(name='MemSize', example='16'),
}
](name='InstanceTypeSpec')
}(name='InstanceTypeSpecList'),
requestId?: string(name='RequestId', example='DD23BBB4-64C2-42A4-B2E2-7E56C7AA815A'),
}
model DescribeInstanceTypeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeInstanceTypeResponseBody(name='body'),
}
/**
* @param request DescribeInstanceTypeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeInstanceTypeResponse
*/
async function describeInstanceTypeWithOptions(request: DescribeInstanceTypeRequest, runtime: Util.RuntimeOptions): DescribeInstanceTypeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.instanceType)) {
query['InstanceType'] = request.instanceType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeInstanceType',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeInstanceTypeRequest
* @return DescribeInstanceTypeResponse
*/
async function describeInstanceType(request: DescribeInstanceTypeRequest): DescribeInstanceTypeResponse {
var runtime = new Util.RuntimeOptions{};
return describeInstanceTypeWithOptions(request, runtime);
}
model DescribeInstancesRequest {
clusterId?: string(name='ClusterId', example='hb-bp1u0639js2h7****'),
clusterName?: string(name='ClusterName', example='test'),
dbType?: string(name='DbType', example='hbase'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
resourceGroupId?: string(name='ResourceGroupId', example='rg-4f51d54g5****'),
tag?: [
{
key?: string(name='Key', example='key'),
value?: string(name='Value', example='value'),
}
](name='Tag'),
}
model DescribeInstancesResponseBody = {
instances?: {
instance?: [
{
autoRenewal?: boolean(name='AutoRenewal', example='false'),
backupStatus?: string(name='BackupStatus', example='open'),
clusterId?: string(name='ClusterId', example='hb-bp1u0639js2h7****'),
clusterName?: string(name='ClusterName', example='test'),
clusterType?: string(name='ClusterType', example='cluster'),
coldStorageStatus?: string(name='ColdStorageStatus', example='open'),
coreDiskCount?: string(name='CoreDiskCount', example='2'),
coreDiskSize?: int32(name='CoreDiskSize', example='100'),
coreDiskType?: string(name='CoreDiskType', example='cloud_efficiency'),
coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.large'),
coreNodeCount?: int32(name='CoreNodeCount', example='2'),
createdTime?: string(name='CreatedTime', example='2019-09-12T14:40:46'),
createdTimeUTC?: string(name='CreatedTimeUTC', example='2019-09-12T14:40:46Z'),
duration?: int32(name='Duration', example='12'),
engine?: string(name='Engine', example='hbase'),
expireTime?: string(name='ExpireTime', example='2019-10-12T14:40:46'),
expireTimeUTC?: string(name='ExpireTimeUTC', example='2019-10-12T14:40:46Z'),
instanceId?: string(name='InstanceId', example='hb-bp1u0639js2h7****'),
instanceName?: string(name='InstanceName', example='test'),
isDeletionProtection?: boolean(name='IsDeletionProtection', example='true'),
isHa?: boolean(name='IsHa', example='true'),
majorVersion?: string(name='MajorVersion', example='2.0'),
masterDiskSize?: int32(name='MasterDiskSize', example='100'),
masterDiskType?: string(name='MasterDiskType', example='cloud_efficiency'),
masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.large'),
masterNodeCount?: int32(name='MasterNodeCount', example='2'),
moduleId?: int32(name='ModuleId', example='0'),
moduleStackVersion?: string(name='ModuleStackVersion', example='1.0'),
networkType?: string(name='NetworkType', example='VPC'),
parentId?: string(name='ParentId', example='2980****2123'),
payType?: string(name='PayType', example='Prepaid'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
resourceGroupId?: string(name='ResourceGroupId', example='rg-4f51d54g5****'),
status?: string(name='Status', example='ACTIVATION'),
tags?: {
tag?: [
{
key?: string(name='Key', example='test-key'),
value?: string(name='Value', example='test-value'),
}
](name='Tag')
}(name='Tags'),
vpcId?: string(name='VpcId', example='vpc-bp120k6ixs4eoghz*****'),
vswitchId?: string(name='VswitchId', example='vsw-bp191ipotq****dbqf'),
zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}
](name='Instance')
}(name='Instances'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='EBECBF12-2E34-41BE-8DE9-FC3700D4****'),
totalCount?: long(name='TotalCount', example='18'),
}
model DescribeInstancesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeInstancesResponseBody(name='body'),
}
/**
* @param request DescribeInstancesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeInstancesResponse
*/
async function describeInstancesWithOptions(request: DescribeInstancesRequest, runtime: Util.RuntimeOptions): DescribeInstancesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.clusterName)) {
query['ClusterName'] = request.clusterName;
}
if (!Util.isUnset(request.dbType)) {
query['DbType'] = request.dbType;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceGroupId)) {
query['ResourceGroupId'] = request.resourceGroupId;
}
if (!Util.isUnset(request.tag)) {
query['Tag'] = request.tag;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeInstances',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeInstancesRequest
* @return DescribeInstancesResponse
*/
async function describeInstances(request: DescribeInstancesRequest): DescribeInstancesResponse {
var runtime = new Util.RuntimeOptions{};
return describeInstancesWithOptions(request, runtime);
}
model DescribeIpWhitelistRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}
model DescribeIpWhitelistResponseBody = {
groups?: {
group?: [
{
groupName?: string(name='GroupName', example='default'),
ipList?: {
ip?: [ string ](name='Ip')
}(name='IpList'),
ipVersion?: int32(name='IpVersion', example='4'),
}
](name='Group')
}(name='Groups'),
requestId?: string(name='RequestId', example='AFAA617B-3268-5883-982B-DB8EC8CC1F1B'),
}
model DescribeIpWhitelistResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeIpWhitelistResponseBody(name='body'),
}
/**
* @param request DescribeIpWhitelistRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeIpWhitelistResponse
*/
async function describeIpWhitelistWithOptions(request: DescribeIpWhitelistRequest, runtime: Util.RuntimeOptions): DescribeIpWhitelistResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeIpWhitelist',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeIpWhitelistRequest
* @return DescribeIpWhitelistResponse
*/
async function describeIpWhitelist(request: DescribeIpWhitelistRequest): DescribeIpWhitelistResponse {
var runtime = new Util.RuntimeOptions{};
return describeIpWhitelistWithOptions(request, runtime);
}
model DescribeMultiZoneAvailableRegionsRequest {
acceptLanguage?: string(name='AcceptLanguage', example='zh-CN'),
}
model DescribeMultiZoneAvailableRegionsResponseBody = {
regions?: {
region?: [
{
availableCombines?: {
availableCombine?: [
{
id?: string(name='Id', example='cn-shenzhen-****-aliyun'),
zones?: {
zone?: [ string ](name='Zone')
}(name='Zones'),
}
](name='AvailableCombine')
}(name='AvailableCombines'),
localName?: string(name='LocalName'),
regionEndpoint?: string(name='RegionEndpoint', example='hbase.aliyuncs.com'),
regionId?: string(name='RegionId', example='cn-shenzhen'),
}
](name='Region')
}(name='Regions'),
requestId?: string(name='RequestId', example='F03BB273-45EE-4B6C-A329-A6E6A8D15856'),
}
model DescribeMultiZoneAvailableRegionsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeMultiZoneAvailableRegionsResponseBody(name='body'),
}
/**
* @param request DescribeMultiZoneAvailableRegionsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeMultiZoneAvailableRegionsResponse
*/
async function describeMultiZoneAvailableRegionsWithOptions(request: DescribeMultiZoneAvailableRegionsRequest, runtime: Util.RuntimeOptions): DescribeMultiZoneAvailableRegionsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.acceptLanguage)) {
query['AcceptLanguage'] = request.acceptLanguage;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeMultiZoneAvailableRegions',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeMultiZoneAvailableRegionsRequest
* @return DescribeMultiZoneAvailableRegionsResponse
*/
async function describeMultiZoneAvailableRegions(request: DescribeMultiZoneAvailableRegionsRequest): DescribeMultiZoneAvailableRegionsResponse {
var runtime = new Util.RuntimeOptions{};
return describeMultiZoneAvailableRegionsWithOptions(request, runtime);
}
model DescribeMultiZoneAvailableResourceRequest {
chargeType?: string(name='ChargeType', description='This parameter is required.', example='Prepaid'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
zoneCombination?: string(name='ZoneCombination', example='cn-hangzhou-bef-aliyun'),
}
model DescribeMultiZoneAvailableResourceResponseBody = {
availableZones?: {
availableZone?: [
{
masterResources?: {
masterResource?: [
{
instanceType?: string(name='InstanceType', example='hbase.sn2.large'),
instanceTypeDetail?: {
cpu?: int32(name='Cpu', example='4'),
mem?: int32(name='Mem', example='16'),
}(name='InstanceTypeDetail'),
}
](name='MasterResource')
}(name='MasterResources'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
supportedEngines?: {
supportedEngine?: [
{
engine?: string(name='Engine', example='hbaseue'),
supportedEngineVersions?: {
supportedEngineVersion?: [
{
supportedCategories?: {
supportedCategories?: [
{
category?: string(name='Category', example='cluster'),
supportedStorageTypes?: {
supportedStorageType?: [
{
coreResources?: {
coreResource?: [
{
DBInstanceStorageRange?: {
maxSize?: int32(name='MaxSize', example='64000'),
minSize?: int32(name='MinSize', example='400'),
stepSize?: int32(name='StepSize', example='40'),
}(name='DBInstanceStorageRange'),
instanceType?: string(name='InstanceType', example='hbase.sn2.2xlarge'),
instanceTypeDetail?: {
cpu?: int32(name='Cpu', example='32'),
mem?: int32(name='Mem', example='8'),
}(name='InstanceTypeDetail'),
maxCoreCount?: int32(name='MaxCoreCount', example='30'),
}
](name='CoreResource')
}(name='CoreResources'),
storageType?: string(name='StorageType', example='cloud_efficiency'),
}
](name='SupportedStorageType')
}(name='SupportedStorageTypes'),
}
](name='SupportedCategories')
}(name='SupportedCategories'),
version?: string(name='Version', example='2.0'),
}
](name='SupportedEngineVersion')
}(name='SupportedEngineVersions'),
}
](name='SupportedEngine')
}(name='SupportedEngines'),
zoneCombination?: string(name='ZoneCombination', example='cn-hangzhou-bef-aliyun'),
}
](name='AvailableZone')
}(name='AvailableZones'),
requestId?: string(name='RequestId', example='B2EEBBA9-C627-4415-81A0-B77BC54F1D52'),
}
model DescribeMultiZoneAvailableResourceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeMultiZoneAvailableResourceResponseBody(name='body'),
}
/**
* @param request DescribeMultiZoneAvailableResourceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeMultiZoneAvailableResourceResponse
*/
async function describeMultiZoneAvailableResourceWithOptions(request: DescribeMultiZoneAvailableResourceRequest, runtime: Util.RuntimeOptions): DescribeMultiZoneAvailableResourceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.chargeType)) {
query['ChargeType'] = request.chargeType;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.zoneCombination)) {
query['ZoneCombination'] = request.zoneCombination;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeMultiZoneAvailableResource',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeMultiZoneAvailableResourceRequest
* @return DescribeMultiZoneAvailableResourceResponse
*/
async function describeMultiZoneAvailableResource(request: DescribeMultiZoneAvailableResourceRequest): DescribeMultiZoneAvailableResourceResponse {
var runtime = new Util.RuntimeOptions{};
return describeMultiZoneAvailableResourceWithOptions(request, runtime);
}
model DescribeMultiZoneClusterRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-t4nn71xa0yn****'),
}
model DescribeMultiZoneClusterResponseBody = {
arbiterVSwitchIds?: string(name='ArbiterVSwitchIds', example='vsw-t4nax9mp3wk0czn****'),
arbiterZoneId?: string(name='ArbiterZoneId', example='ap-southeast-1c'),
autoRenewal?: boolean(name='AutoRenewal', example='false'),
clusterId?: string(name='ClusterId', example='ld-t4nn71xa0yn****'),
clusterName?: string(name='ClusterName', example='mz_test'),
coldStorageSize?: int32(name='ColdStorageSize'),
coreDiskCount?: string(name='CoreDiskCount', example='4'),
coreDiskSize?: int32(name='CoreDiskSize', example='100'),
coreDiskType?: string(name='CoreDiskType', example='cloud_efficiency'),
coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.large'),
coreNodeCount?: int32(name='CoreNodeCount', example='6'),
createdTime?: string(name='CreatedTime', example='2020-10-15T18:04:52'),
createdTimeUTC?: string(name='CreatedTimeUTC', example='2020-10-15T10:04:52Z'),
duration?: int32(name='Duration', example='1'),
encryptionKey?: string(name='EncryptionKey', example='2a****'),
encryptionType?: string(name='EncryptionType', example='CloudDisk'),
engine?: string(name='Engine', example='hbaseue'),
expireTime?: string(name='ExpireTime', example='2020-11-16T08:00:00'),
expireTimeUTC?: string(name='ExpireTimeUTC', example='2020-11-16T00:00:00Z'),
instanceId?: string(name='InstanceId', example='ld-t4nn71xa0yn****'),
instanceName?: string(name='InstanceName', example='mz_test'),
isDeletionProtection?: boolean(name='IsDeletionProtection', example='false'),
logDiskCount?: string(name='LogDiskCount', example='4'),
logDiskSize?: int32(name='LogDiskSize', example='100'),
logDiskType?: string(name='LogDiskType', example='cloud_efficiency'),
logInstanceType?: string(name='LogInstanceType', example='hbase.sn1.large'),
logNodeCount?: int32(name='LogNodeCount', example='4'),
maintainEndTime?: string(name='MaintainEndTime', example='06:00:00'),
maintainStartTime?: string(name='MaintainStartTime', example='02:00:00'),
majorVersion?: string(name='MajorVersion', example='2.0'),
masterDiskSize?: int32(name='MasterDiskSize', example='50'),
masterDiskType?: string(name='MasterDiskType', example='cloud_efficiency'),
masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.large'),
masterNodeCount?: int32(name='MasterNodeCount', example='2'),
moduleId?: int32(name='ModuleId', example='0'),
moduleStackVersion?: string(name='ModuleStackVersion', example='2.0'),
multiZoneCombination?: string(name='MultiZoneCombination', example='ap-southeast-1-abc-aliyun'),
multiZoneInstanceModels?: {
multiZoneInstanceModel?: [
{
hdfsMinorVersion?: string(name='HdfsMinorVersion'),
insName?: string(name='InsName', example='ld-t4nn71xa0yn****-az-a'),
isHdfsLatestVersion?: string(name='IsHdfsLatestVersion'),
isLatestVersion?: boolean(name='IsLatestVersion', example='true'),
latestHdfsMinorVersion?: string(name='LatestHdfsMinorVersion'),
latestMinorVersion?: string(name='LatestMinorVersion'),
minorVersion?: string(name='MinorVersion', example='2.1.24'),
role?: string(name='Role', example='primary'),
status?: string(name='Status', example='ACTIVATION'),
}
](name='MultiZoneInstanceModel')
}(name='MultiZoneInstanceModels'),
networkType?: string(name='NetworkType', example='VPC'),
parentId?: string(name='ParentId', example='ld-fls1gf31y5s35****'),
payType?: string(name='PayType', example='Prepaid'),
primaryVSwitchIds?: string(name='PrimaryVSwitchIds', example='vsw-t4n3s1zd2gtidg****'),
primaryZoneId?: string(name='PrimaryZoneId', example='ap-southeast-1a'),
regionId?: string(name='RegionId', example='ap-southeast-1'),
requestId?: string(name='RequestId', example='A02C0E6D-3A47-4FA0-BA7E-60793CE256DA'),
resourceGroupId?: string(name='ResourceGroupId', example='rg-lk51f5fer315e****'),
standbyVSwitchIds?: string(name='StandbyVSwitchIds', example='vsw-t4nvvk7xur3rdi****'),
standbyZoneId?: string(name='StandbyZoneId', example='ap-southeast-1b'),
status?: string(name='Status', example='ACTIVATION'),
tags?: {
tag?: [
{
key?: string(name='Key', example='test_key'),
value?: string(name='Value', example='test_value'),
}
](name='Tag')
}(name='Tags'),
taskProgress?: string(name='TaskProgress'),
taskStatus?: string(name='TaskStatus'),
vpcId?: string(name='VpcId', example='vpc-t4nx81tmlixcq5****'),
}
model DescribeMultiZoneClusterResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeMultiZoneClusterResponseBody(name='body'),
}
/**
* @param request DescribeMultiZoneClusterRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeMultiZoneClusterResponse
*/
async function describeMultiZoneClusterWithOptions(request: DescribeMultiZoneClusterRequest, runtime: Util.RuntimeOptions): DescribeMultiZoneClusterResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeMultiZoneCluster',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeMultiZoneClusterRequest
* @return DescribeMultiZoneClusterResponse
*/
async function describeMultiZoneCluster(request: DescribeMultiZoneClusterRequest): DescribeMultiZoneClusterResponse {
var runtime = new Util.RuntimeOptions{};
return describeMultiZoneClusterWithOptions(request, runtime);
}
model DescribeRecoverableTimeRangeRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
}
model DescribeRecoverableTimeRangeResponseBody = {
requestId?: string(name='RequestId', example='A1A51D18-96DC-465C-9F1B-47180CA22524'),
timeBegin?: string(name='TimeBegin', example='2020-10-26T18:02:03Z'),
timeEnd?: string(name='TimeEnd', example='2020-11-05T01:20:31Z'),
}
model DescribeRecoverableTimeRangeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeRecoverableTimeRangeResponseBody(name='body'),
}
/**
* @param request DescribeRecoverableTimeRangeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeRecoverableTimeRangeResponse
*/
async function describeRecoverableTimeRangeWithOptions(request: DescribeRecoverableTimeRangeRequest, runtime: Util.RuntimeOptions): DescribeRecoverableTimeRangeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeRecoverableTimeRange',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeRecoverableTimeRangeRequest
* @return DescribeRecoverableTimeRangeResponse
*/
async function describeRecoverableTimeRange(request: DescribeRecoverableTimeRangeRequest): DescribeRecoverableTimeRangeResponse {
var runtime = new Util.RuntimeOptions{};
return describeRecoverableTimeRangeWithOptions(request, runtime);
}
model DescribeRegionsRequest {
acceptLanguage?: string(name='AcceptLanguage', example='zh-CN'),
engine?: string(name='Engine', example='hbase'),
}
model DescribeRegionsResponseBody = {
regions?: {
region?: [
{
localName?: string(name='LocalName'),
regionEndpoint?: string(name='RegionEndpoint', example='hbase.aliyuncs.com'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
zones?: {
zone?: [
{
id?: string(name='Id', example='cn-hangzhou-b'),
}
](name='Zone')
}(name='Zones'),
}
](name='Region')
}(name='Regions'),
requestId?: string(name='RequestId', example='14D3924C-4FD8-4EE9-9B34-DA949D104F42'),
}
model DescribeRegionsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeRegionsResponseBody(name='body'),
}
/**
* @param request DescribeRegionsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeRegionsResponse
*/
async function describeRegionsWithOptions(request: DescribeRegionsRequest, runtime: Util.RuntimeOptions): DescribeRegionsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.acceptLanguage)) {
query['AcceptLanguage'] = request.acceptLanguage;
}
if (!Util.isUnset(request.engine)) {
query['Engine'] = request.engine;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeRegions',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeRegionsRequest
* @return DescribeRegionsResponse
*/
async function describeRegions(request: DescribeRegionsRequest): DescribeRegionsResponse {
var runtime = new Util.RuntimeOptions{};
return describeRegionsWithOptions(request, runtime);
}
model DescribeRestoreFullDetailsRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
restoreRecordId?: string(name='RestoreRecordId', description='This parameter is required.', example='2020110514xxxx'),
}
model DescribeRestoreFullDetailsResponseBody = {
requestId?: string(name='RequestId', example='CFE525CF-C691-4140-A981-D004DAA7A840'),
restoreFull?: {
dataSize?: string(name='DataSize', example='1.2 kB'),
fail?: int32(name='Fail', example='0'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
restoreFullDetails?: {
restoreFullDetail?: [
{
dataSize?: string(name='DataSize', example='1.2 kB'),
endTime?: string(name='EndTime', example='2020-11-05T06:45:51Z'),
message?: string(name='Message', example='null'),
process?: string(name='Process', example='14/14'),
speed?: string(name='Speed', example='0.00 MB/s'),
startTime?: string(name='StartTime', example='2020-11-05T06:45:45Z'),
state?: string(name='State', example='SUCCEEDED'),
table?: string(name='Table', example='default:test1'),
}
](name='RestoreFullDetail')
}(name='RestoreFullDetails'),
speed?: string(name='Speed', example='0.00 MB/s'),
succeed?: int32(name='Succeed', example='1'),
total?: long(name='Total', example='1'),
}(name='RestoreFull'),
}
model DescribeRestoreFullDetailsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeRestoreFullDetailsResponseBody(name='body'),
}
/**
* @param request DescribeRestoreFullDetailsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeRestoreFullDetailsResponse
*/
async function describeRestoreFullDetailsWithOptions(request: DescribeRestoreFullDetailsRequest, runtime: Util.RuntimeOptions): DescribeRestoreFullDetailsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.restoreRecordId)) {
query['RestoreRecordId'] = request.restoreRecordId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeRestoreFullDetails',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeRestoreFullDetailsRequest
* @return DescribeRestoreFullDetailsResponse
*/
async function describeRestoreFullDetails(request: DescribeRestoreFullDetailsRequest): DescribeRestoreFullDetailsResponse {
var runtime = new Util.RuntimeOptions{};
return describeRestoreFullDetailsWithOptions(request, runtime);
}
model DescribeRestoreIncrDetailRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eyf188hw481xxxx'),
restoreRecordId?: string(name='RestoreRecordId', description='This parameter is required.', example='2020110514xxxx'),
}
model DescribeRestoreIncrDetailResponseBody = {
requestId?: string(name='RequestId', example='D0FE2717-E194-465A-B27B-7373F96E580B'),
restoreIncrDetail?: {
endTime?: string(name='EndTime', example='2020-11-05T06:45:44Z'),
process?: string(name='Process', example='0/0'),
restoreDelay?: string(name='RestoreDelay', example='0 ms'),
restoreStartTs?: string(name='RestoreStartTs', example='2020-11-02T18:00:00Z'),
restoredTs?: string(name='RestoredTs', example='\\\\"\\\\"'),
startTime?: string(name='StartTime', example='2020-11-05T06:45:44Z'),
state?: string(name='State', example='SUCCEEDED'),
}(name='RestoreIncrDetail'),
}
model DescribeRestoreIncrDetailResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeRestoreIncrDetailResponseBody(name='body'),
}
/**
* @param request DescribeRestoreIncrDetailRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeRestoreIncrDetailResponse
*/
async function describeRestoreIncrDetailWithOptions(request: DescribeRestoreIncrDetailRequest, runtime: Util.RuntimeOptions): DescribeRestoreIncrDetailResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.restoreRecordId)) {
query['RestoreRecordId'] = request.restoreRecordId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeRestoreIncrDetail',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeRestoreIncrDetailRequest
* @return DescribeRestoreIncrDetailResponse
*/
async function describeRestoreIncrDetail(request: DescribeRestoreIncrDetailRequest): DescribeRestoreIncrDetailResponse {
var runtime = new Util.RuntimeOptions{};
return describeRestoreIncrDetailWithOptions(request, runtime);
}
model DescribeRestoreSchemaDetailsRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
restoreRecordId?: string(name='RestoreRecordId', description='This parameter is required.', example='2020110514xxxx'),
}
model DescribeRestoreSchemaDetailsResponseBody = {
requestId?: string(name='RequestId', example='BC682A80-7677-4294-975C-CFEA425381DE'),
restoreSchema?: {
fail?: int32(name='Fail', example='0'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
restoreSchemaDetails?: {
restoreSchemaDetail?: [
{
endTime?: string(name='EndTime', example='2020-11-05T06:45:18Z'),
message?: string(name='Message', example='null'),
startTime?: string(name='StartTime', example='2020-11-05T06:45:14Z'),
state?: string(name='State', example='SUCCEEDED'),
table?: string(name='Table', example='default:test1'),
}
](name='RestoreSchemaDetail')
}(name='RestoreSchemaDetails'),
succeed?: int32(name='Succeed', example='1'),
total?: long(name='Total', example='1'),
}(name='RestoreSchema'),
}
model DescribeRestoreSchemaDetailsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeRestoreSchemaDetailsResponseBody(name='body'),
}
/**
* @param request DescribeRestoreSchemaDetailsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeRestoreSchemaDetailsResponse
*/
async function describeRestoreSchemaDetailsWithOptions(request: DescribeRestoreSchemaDetailsRequest, runtime: Util.RuntimeOptions): DescribeRestoreSchemaDetailsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.restoreRecordId)) {
query['RestoreRecordId'] = request.restoreRecordId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeRestoreSchemaDetails',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeRestoreSchemaDetailsRequest
* @return DescribeRestoreSchemaDetailsResponse
*/
async function describeRestoreSchemaDetails(request: DescribeRestoreSchemaDetailsRequest): DescribeRestoreSchemaDetailsResponse {
var runtime = new Util.RuntimeOptions{};
return describeRestoreSchemaDetailsWithOptions(request, runtime);
}
model DescribeRestoreSummaryRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
}
model DescribeRestoreSummaryResponseBody = {
hasMoreRestoreRecord?: int32(name='HasMoreRestoreRecord', example='0'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='AE639ED7-F0F3-4A71-911E-CF8EC088816E'),
rescords?: {
rescord?: [
{
bulkLoadProcess?: string(name='BulkLoadProcess', example='1/1'),
createTime?: string(name='CreateTime', example='2020-11-05T06:45:14Z'),
finishTime?: string(name='FinishTime', example='2020-11-05T06:45:51Z'),
hfileRestoreProcess?: string(name='HfileRestoreProcess', example='1/1'),
logProcess?: string(name='LogProcess', example='0/0'),
recordId?: string(name='RecordId', example='20201105144514'),
schemaProcess?: string(name='SchemaProcess', example='1/1'),
status?: string(name='Status', example='SUCCEEDED'),
}
](name='Rescord')
}(name='Rescords'),
total?: int32(name='Total', example='1'),
}
model DescribeRestoreSummaryResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeRestoreSummaryResponseBody(name='body'),
}
/**
* @param request DescribeRestoreSummaryRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeRestoreSummaryResponse
*/
async function describeRestoreSummaryWithOptions(request: DescribeRestoreSummaryRequest, runtime: Util.RuntimeOptions): DescribeRestoreSummaryResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeRestoreSummary',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeRestoreSummaryRequest
* @return DescribeRestoreSummaryResponse
*/
async function describeRestoreSummary(request: DescribeRestoreSummaryRequest): DescribeRestoreSummaryResponse {
var runtime = new Util.RuntimeOptions{};
return describeRestoreSummaryWithOptions(request, runtime);
}
model DescribeRestoreTablesRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
restoreRecordId?: string(name='RestoreRecordId', description='This parameter is required.', example='2020110514xxxx'),
}
model DescribeRestoreTablesResponseBody = {
requestId?: string(name='RequestId', example='18D9CC47-D913-48BF-AB6B-4FA9B28FBDB1'),
restoreFull?: {
dataSize?: string(name='DataSize', example='1.2 kB'),
fail?: int32(name='Fail', example='0'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
restoreFullDetails?: {
restoreFullDetail?: [
{
dataSize?: string(name='DataSize', example='1.2 kB'),
endTime?: string(name='EndTime', example='2020-11-05T06:45:51Z'),
message?: string(name='Message', example='“”'),
process?: string(name='Process', example='14/14'),
speed?: string(name='Speed', example='0.00 MB/s'),
startTime?: string(name='StartTime', example='2020-11-05T06:45:45Z'),
state?: string(name='State', example='SUCCEEDED'),
table?: string(name='Table', example='default:test1'),
}
](name='RestoreFullDetail')
}(name='RestoreFullDetails'),
speed?: string(name='Speed', example='0.00 MB/s'),
succeed?: int32(name='Succeed', example='1'),
total?: long(name='Total', example='1'),
}(name='RestoreFull'),
restoreIncrDetail?: {
endTime?: string(name='EndTime', example='2020-11-05T06:45:44Z'),
process?: string(name='Process', example='0/0'),
restoreDelay?: string(name='RestoreDelay', example='0 ms'),
restoreStartTs?: string(name='RestoreStartTs', example='2020-11-02T18:00:00Z'),
restoredTs?: string(name='RestoredTs', example='“”'),
startTime?: string(name='StartTime', example='2020-11-05T06:45:44Z'),
state?: string(name='State', example='SUCCEEDED'),
}(name='RestoreIncrDetail'),
restoreSchema?: {
fail?: int32(name='Fail', example='0'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
restoreSchemaDetails?: {
restoreSchemaDetail?: [
{
endTime?: string(name='EndTime', example='2020-11-05T06:45:18Z'),
message?: string(name='Message', example='null'),
startTime?: string(name='StartTime', example='2020-11-05T06:45:14Z'),
state?: string(name='State', example='SUCCEEDED'),
table?: string(name='Table', example='default:test1'),
}
](name='RestoreSchemaDetail')
}(name='RestoreSchemaDetails'),
succeed?: int32(name='Succeed', example='1'),
total?: long(name='Total', example='1'),
}(name='RestoreSchema'),
restoreSummary?: {
endTime?: string(name='EndTime', example='2020-11-05T06:45:51Z'),
recordId?: string(name='RecordId', example='20201105144514'),
restoreToDate?: string(name='RestoreToDate', example='2020-11-04T05:15:00Z'),
startTime?: string(name='StartTime', example='2020-11-05T06:45:14Z'),
state?: string(name='State', example='SUCCEEDED'),
targetCluster?: string(name='TargetCluster', example='ld-m5e2t34kr54wgxxxx'),
}(name='RestoreSummary'),
tables?: {
table?: [ string ](name='Table')
}(name='Tables'),
}
model DescribeRestoreTablesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeRestoreTablesResponseBody(name='body'),
}
/**
* @param request DescribeRestoreTablesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeRestoreTablesResponse
*/
async function describeRestoreTablesWithOptions(request: DescribeRestoreTablesRequest, runtime: Util.RuntimeOptions): DescribeRestoreTablesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.restoreRecordId)) {
query['RestoreRecordId'] = request.restoreRecordId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeRestoreTables',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeRestoreTablesRequest
* @return DescribeRestoreTablesResponse
*/
async function describeRestoreTables(request: DescribeRestoreTablesRequest): DescribeRestoreTablesResponse {
var runtime = new Util.RuntimeOptions{};
return describeRestoreTablesWithOptions(request, runtime);
}
model DescribeSecurityGroupsRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp161ax8i03c4uq**'),
}
model DescribeSecurityGroupsResponseBody = {
requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
securityGroupIds?: {
securityGroupId?: [ string ](name='SecurityGroupId')
}(name='SecurityGroupIds'),
}
model DescribeSecurityGroupsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeSecurityGroupsResponseBody(name='body'),
}
/**
* @param request DescribeSecurityGroupsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeSecurityGroupsResponse
*/
async function describeSecurityGroupsWithOptions(request: DescribeSecurityGroupsRequest, runtime: Util.RuntimeOptions): DescribeSecurityGroupsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeSecurityGroups',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeSecurityGroupsRequest
* @return DescribeSecurityGroupsResponse
*/
async function describeSecurityGroups(request: DescribeSecurityGroupsRequest): DescribeSecurityGroupsResponse {
var runtime = new Util.RuntimeOptions{};
return describeSecurityGroupsWithOptions(request, runtime);
}
model DescribeServerlessClusterRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16f1441y6p2****'),
zoneId?: string(name='ZoneId', description='This parameter is required.', example='sdh0b7f4k5f****'),
}
model DescribeServerlessClusterResponseBody = {
autoRenew?: string(name='AutoRenew', example='false'),
clusterType?: string(name='ClusterType', example='single'),
createTime?: string(name='CreateTime', example='2019-10-12T14:40:46'),
cuSize?: string(name='CuSize', example='150'),
diskSize?: string(name='DiskSize', example='200'),
expireTime?: string(name='ExpireTime', example='2019-10-12T14:40:46'),
haType?: string(name='HaType', example='false'),
hasUser?: string(name='HasUser', example='false'),
innerEndpoint?: string(name='InnerEndpoint', example='https://sh-wz91452kg946i****-lindorm-serverless-in.lindorm.rds.aliyuncs.com:443'),
instanceId?: string(name='InstanceId', example='hb-bp16f1441y6p2****'),
instanceName?: string(name='InstanceName', example='test'),
isDeletionProtection?: string(name='IsDeletionProtection', example='true'),
lockMode?: string(name='LockMode'),
mainVersion?: string(name='MainVersion', example='2.0.8'),
outerEndpoint?: string(name='OuterEndpoint', example='https://sh-wz91452kg946i****-lindorm-serverless.lindorm.rds.aliyuncs.com:443'),
payType?: string(name='PayType', example='Postpaid'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
requestId?: string(name='RequestId', example='89F81C30-320B-4550-91DB-C37C81D2358F'),
reserverMaxQpsNum?: string(name='ReserverMaxQpsNum', example='100'),
reserverMinQpsNum?: string(name='ReserverMinQpsNum', example='50'),
resourceGroupId?: string(name='ResourceGroupId', example='rg-fjm2d4v7sf****'),
status?: string(name='Status', example='ACTIVATION'),
updateStatus?: string(name='UpdateStatus', example='NO'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp191ipotqf****'),
vpcId?: string(name='VpcId', example='vpc-bp120k6ixs4eoghz****'),
zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}
model DescribeServerlessClusterResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeServerlessClusterResponseBody(name='body'),
}
/**
* @param request DescribeServerlessClusterRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeServerlessClusterResponse
*/
async function describeServerlessClusterWithOptions(request: DescribeServerlessClusterRequest, runtime: Util.RuntimeOptions): DescribeServerlessClusterResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeServerlessCluster',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeServerlessClusterRequest
* @return DescribeServerlessClusterResponse
*/
async function describeServerlessCluster(request: DescribeServerlessClusterRequest): DescribeServerlessClusterResponse {
var runtime = new Util.RuntimeOptions{};
return describeServerlessClusterWithOptions(request, runtime);
}
model DescribeSubDomainRequest {
regionId?: string(name='RegionId', example='cn-hangzhou'),
zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}
model DescribeSubDomainResponseBody = {
requestId?: string(name='RequestId', example='F4208C83-B9BC-4A64-A739-8F88E98DA469'),
subDomain?: string(name='SubDomain', example='cn-hangzhou-h-aliyun'),
}
model DescribeSubDomainResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeSubDomainResponseBody(name='body'),
}
/**
* @param request DescribeSubDomainRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeSubDomainResponse
*/
async function describeSubDomainWithOptions(request: DescribeSubDomainRequest, runtime: Util.RuntimeOptions): DescribeSubDomainResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeSubDomain',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request DescribeSubDomainRequest
* @return DescribeSubDomainResponse
*/
async function describeSubDomain(request: DescribeSubDomainRequest): DescribeSubDomainResponse {
var runtime = new Util.RuntimeOptions{};
return describeSubDomainWithOptions(request, runtime);
}
model EnableHBaseueBackupRequest {
clientToken?: string(name='ClientToken', example='xxx'),
coldStorageSize?: int32(name='ColdStorageSize', example='800'),
hbaseueClusterId?: string(name='HbaseueClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
nodeCount?: int32(name='NodeCount', description='This parameter is required.', example='2'),
}
model EnableHBaseueBackupResponseBody = {
clusterId?: string(name='ClusterId', example='bds-m5e54q06ceyhxxxx'),
orderId?: string(name='OrderId', example='1449xxx'),
requestId?: string(name='RequestId', example='15272D5D-46E8-4400-9CC8-A7E7B589F575'),
}
model EnableHBaseueBackupResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: EnableHBaseueBackupResponseBody(name='body'),
}
/**
* @param request EnableHBaseueBackupRequest
* @param runtime runtime options for this request RuntimeOptions
* @return EnableHBaseueBackupResponse
*/
async function enableHBaseueBackupWithOptions(request: EnableHBaseueBackupRequest, runtime: Util.RuntimeOptions): EnableHBaseueBackupResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.coldStorageSize)) {
query['ColdStorageSize'] = request.coldStorageSize;
}
if (!Util.isUnset(request.hbaseueClusterId)) {
query['HbaseueClusterId'] = request.hbaseueClusterId;
}
if (!Util.isUnset(request.nodeCount)) {
query['NodeCount'] = request.nodeCount;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'EnableHBaseueBackup',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request EnableHBaseueBackupRequest
* @return EnableHBaseueBackupResponse
*/
async function enableHBaseueBackup(request: EnableHBaseueBackupRequest): EnableHBaseueBackupResponse {
var runtime = new Util.RuntimeOptions{};
return enableHBaseueBackupWithOptions(request, runtime);
}
model EnableHBaseueModuleRequest {
autoRenewPeriod?: int32(name='AutoRenewPeriod', example='2'),
bdsId?: string(name='BdsId', example='bds-bp174pm3tsk3****'),
clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
coreInstanceType?: string(name='CoreInstanceType', description='This parameter is required.', example='hbase.sn1.large'),
diskSize?: int32(name='DiskSize', example='400'),
diskType?: string(name='DiskType', example='cloud_ssd'),
hbaseueClusterId?: string(name='HbaseueClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.large'),
moduleClusterName?: string(name='ModuleClusterName', example='cluster-name'),
moduleTypeName?: string(name='ModuleTypeName', description='This parameter is required.', example='solr'),
nodeCount?: int32(name='NodeCount', description='This parameter is required.', example='2'),
payType?: string(name='PayType', description='This parameter is required.', example='Prepaid'),
period?: int32(name='Period', example='6'),
periodUnit?: string(name='PeriodUnit', example='month'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-shenzhen'),
vpcId?: string(name='VpcId', description='This parameter is required.', example='vpc-bp120k6ixs4eog*****'),
vswitchId?: string(name='VswitchId', description='This parameter is required.', example='vsw-bp191ipotqj1ssyl*****'),
zoneId?: string(name='ZoneId', description='This parameter is required.', example='cn-shenzhen-e'),
}
model EnableHBaseueModuleResponseBody = {
clusterId?: string(name='ClusterId', example='ld-bp150tns0sjxs****-m1-ps'),
orderId?: string(name='OrderId', example='21474915573****'),
requestId?: string(name='RequestId', example='407075EA-47F5-5A2D-888F-C1F90B8F3FCA'),
}
model EnableHBaseueModuleResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: EnableHBaseueModuleResponseBody(name='body'),
}
/**
* @param request EnableHBaseueModuleRequest
* @param runtime runtime options for this request RuntimeOptions
* @return EnableHBaseueModuleResponse
*/
async function enableHBaseueModuleWithOptions(request: EnableHBaseueModuleRequest, runtime: Util.RuntimeOptions): EnableHBaseueModuleResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.autoRenewPeriod)) {
query['AutoRenewPeriod'] = request.autoRenewPeriod;
}
if (!Util.isUnset(request.bdsId)) {
query['BdsId'] = request.bdsId;
}
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.coreInstanceType)) {
query['CoreInstanceType'] = request.coreInstanceType;
}
if (!Util.isUnset(request.diskSize)) {
query['DiskSize'] = request.diskSize;
}
if (!Util.isUnset(request.diskType)) {
query['DiskType'] = request.diskType;
}
if (!Util.isUnset(request.hbaseueClusterId)) {
query['HbaseueClusterId'] = request.hbaseueClusterId;
}
if (!Util.isUnset(request.masterInstanceType)) {
query['MasterInstanceType'] = request.masterInstanceType;
}
if (!Util.isUnset(request.moduleClusterName)) {
query['ModuleClusterName'] = request.moduleClusterName;
}
if (!Util.isUnset(request.moduleTypeName)) {
query['ModuleTypeName'] = request.moduleTypeName;
}
if (!Util.isUnset(request.nodeCount)) {
query['NodeCount'] = request.nodeCount;
}
if (!Util.isUnset(request.payType)) {
query['PayType'] = request.payType;
}
if (!Util.isUnset(request.period)) {
query['Period'] = request.period;
}
if (!Util.isUnset(request.periodUnit)) {
query['PeriodUnit'] = request.periodUnit;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
if (!Util.isUnset(request.vswitchId)) {
query['VswitchId'] = request.vswitchId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'EnableHBaseueModule',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request EnableHBaseueModuleRequest
* @return EnableHBaseueModuleResponse
*/
async function enableHBaseueModule(request: EnableHBaseueModuleRequest): EnableHBaseueModuleResponse {
var runtime = new Util.RuntimeOptions{};
return enableHBaseueModuleWithOptions(request, runtime);
}
model EvaluateMultiZoneResourceRequest {
arbiterVSwitchId?: string(name='ArbiterVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxb****'),
arbiterZoneId?: string(name='ArbiterZoneId', description='This parameter is required.', example='cn-hangzhou-b'),
archVersion?: string(name='ArchVersion', description='This parameter is required.', example='2.0'),
autoRenewPeriod?: int32(name='AutoRenewPeriod', example='0'),
clientToken?: string(name='ClientToken', example='f4g8t5rd2gr94****'),
clusterName?: string(name='ClusterName', example='hbaseue_test'),
coreDiskSize?: int32(name='CoreDiskSize', description='This parameter is required.', example='400'),
coreDiskType?: string(name='CoreDiskType', description='This parameter is required.', example='cloud_ssd'),
coreInstanceType?: string(name='CoreInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
coreNodeCount?: int32(name='CoreNodeCount', description='This parameter is required.', example='4'),
engine?: string(name='Engine', description='This parameter is required.', example='hbaseue'),
engineVersion?: string(name='EngineVersion', description='This parameter is required.', example='2.0'),
logDiskSize?: int32(name='LogDiskSize', example='400'),
logDiskType?: string(name='LogDiskType', example='cloud_ssd'),
logInstanceType?: string(name='LogInstanceType', example='hbase.sn1.medium'),
logNodeCount?: int32(name='LogNodeCount', example='4'),
masterInstanceType?: string(name='MasterInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
multiZoneCombination?: string(name='MultiZoneCombination', description='This parameter is required.', example='cn-hangzhou-bef-aliyun-com'),
payType?: string(name='PayType', description='This parameter is required.', example='Postpaid'),
period?: int32(name='Period', example='1'),
periodUnit?: string(name='PeriodUnit', example='month'),
primaryVSwitchId?: string(name='PrimaryVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxe*****'),
primaryZoneId?: string(name='PrimaryZoneId', description='This parameter is required.', example='cn-hangzhou-e'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
securityIPList?: string(name='SecurityIPList', example='127.0.0.1'),
standbyVSwitchId?: string(name='StandbyVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxf****'),
standbyZoneId?: string(name='StandbyZoneId', description='This parameter is required.', example='cn-hangzhou-f'),
vpcId?: string(name='VpcId', description='This parameter is required.', example='vpc-bp120k6ixs4eog*****'),
}
model EvaluateMultiZoneResourceResponseBody = {
requestId?: string(name='RequestId', example='FB703B69-D4D4-4879-B9FE-6A37F67C46FD'),
success?: boolean(name='Success', example='true'),
}
model EvaluateMultiZoneResourceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: EvaluateMultiZoneResourceResponseBody(name='body'),
}
/**
* @param request EvaluateMultiZoneResourceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return EvaluateMultiZoneResourceResponse
*/
async function evaluateMultiZoneResourceWithOptions(request: EvaluateMultiZoneResourceRequest, runtime: Util.RuntimeOptions): EvaluateMultiZoneResourceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.arbiterVSwitchId)) {
query['ArbiterVSwitchId'] = request.arbiterVSwitchId;
}
if (!Util.isUnset(request.arbiterZoneId)) {
query['ArbiterZoneId'] = request.arbiterZoneId;
}
if (!Util.isUnset(request.archVersion)) {
query['ArchVersion'] = request.archVersion;
}
if (!Util.isUnset(request.autoRenewPeriod)) {
query['AutoRenewPeriod'] = request.autoRenewPeriod;
}
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clusterName)) {
query['ClusterName'] = request.clusterName;
}
if (!Util.isUnset(request.coreDiskSize)) {
query['CoreDiskSize'] = request.coreDiskSize;
}
if (!Util.isUnset(request.coreDiskType)) {
query['CoreDiskType'] = request.coreDiskType;
}
if (!Util.isUnset(request.coreInstanceType)) {
query['CoreInstanceType'] = request.coreInstanceType;
}
if (!Util.isUnset(request.coreNodeCount)) {
query['CoreNodeCount'] = request.coreNodeCount;
}
if (!Util.isUnset(request.engine)) {
query['Engine'] = request.engine;
}
if (!Util.isUnset(request.engineVersion)) {
query['EngineVersion'] = request.engineVersion;
}
if (!Util.isUnset(request.logDiskSize)) {
query['LogDiskSize'] = request.logDiskSize;
}
if (!Util.isUnset(request.logDiskType)) {
query['LogDiskType'] = request.logDiskType;
}
if (!Util.isUnset(request.logInstanceType)) {
query['LogInstanceType'] = request.logInstanceType;
}
if (!Util.isUnset(request.logNodeCount)) {
query['LogNodeCount'] = request.logNodeCount;
}
if (!Util.isUnset(request.masterInstanceType)) {
query['MasterInstanceType'] = request.masterInstanceType;
}
if (!Util.isUnset(request.multiZoneCombination)) {
query['MultiZoneCombination'] = request.multiZoneCombination;
}
if (!Util.isUnset(request.payType)) {
query['PayType'] = request.payType;
}
if (!Util.isUnset(request.period)) {
query['Period'] = request.period;
}
if (!Util.isUnset(request.periodUnit)) {
query['PeriodUnit'] = request.periodUnit;
}
if (!Util.isUnset(request.primaryVSwitchId)) {
query['PrimaryVSwitchId'] = request.primaryVSwitchId;
}
if (!Util.isUnset(request.primaryZoneId)) {
query['PrimaryZoneId'] = request.primaryZoneId;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.securityIPList)) {
query['SecurityIPList'] = request.securityIPList;
}
if (!Util.isUnset(request.standbyVSwitchId)) {
query['StandbyVSwitchId'] = request.standbyVSwitchId;
}
if (!Util.isUnset(request.standbyZoneId)) {
query['StandbyZoneId'] = request.standbyZoneId;
}
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'EvaluateMultiZoneResource',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request EvaluateMultiZoneResourceRequest
* @return EvaluateMultiZoneResourceResponse
*/
async function evaluateMultiZoneResource(request: EvaluateMultiZoneResourceRequest): EvaluateMultiZoneResourceResponse {
var runtime = new Util.RuntimeOptions{};
return evaluateMultiZoneResourceWithOptions(request, runtime);
}
model GetMultimodeCmsUrlRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
}
model GetMultimodeCmsUrlResponseBody = {
clusterId?: string(name='ClusterId', example='hb-t4naqsay5gn******'),
multimodCmsUrl?: string(name='MultimodCmsUrl', example='htpp://***********'),
requestId?: string(name='RequestId', example='44183B05-852E-4716-B902-52977140190F'),
}
model GetMultimodeCmsUrlResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: GetMultimodeCmsUrlResponseBody(name='body'),
}
/**
* @param request GetMultimodeCmsUrlRequest
* @param runtime runtime options for this request RuntimeOptions
* @return GetMultimodeCmsUrlResponse
*/
async function getMultimodeCmsUrlWithOptions(request: GetMultimodeCmsUrlRequest, runtime: Util.RuntimeOptions): GetMultimodeCmsUrlResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'GetMultimodeCmsUrl',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request GetMultimodeCmsUrlRequest
* @return GetMultimodeCmsUrlResponse
*/
async function getMultimodeCmsUrl(request: GetMultimodeCmsUrlRequest): GetMultimodeCmsUrlResponse {
var runtime = new Util.RuntimeOptions{};
return getMultimodeCmsUrlWithOptions(request, runtime);
}
model GrantRequest {
accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
aclActions?: string(name='AclActions', description='This parameter is required.', example='READ,WRITE'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
namespace?: string(name='Namespace', description='This parameter is required.', example='default'),
tableName?: string(name='TableName', description='This parameter is required.', example='table'),
}
model GrantResponseBody = {
requestId?: string(name='RequestId', example='9CBF8DF0-4931-4A54-9B60-4C6E1AB5****'),
}
model GrantResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: GrantResponseBody(name='body'),
}
/**
* @summary 授权账户权限
*
* @param request GrantRequest
* @param runtime runtime options for this request RuntimeOptions
* @return GrantResponse
*/
async function grantWithOptions(request: GrantRequest, runtime: Util.RuntimeOptions): GrantResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.accountName)) {
query['AccountName'] = request.accountName;
}
if (!Util.isUnset(request.aclActions)) {
query['AclActions'] = request.aclActions;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.namespace)) {
query['Namespace'] = request.namespace;
}
if (!Util.isUnset(request.tableName)) {
query['TableName'] = request.tableName;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'Grant',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @summary 授权账户权限
*
* @param request GrantRequest
* @return GrantResponse
*/
async function grant(request: GrantRequest): GrantResponse {
var runtime = new Util.RuntimeOptions{};
return grantWithOptions(request, runtime);
}
model ListHBaseInstancesRequest {
vpcId?: string(name='VpcId', description='This parameter is required.', example='vpc-t4nx81tmlixcq5i****'),
}
model ListHBaseInstancesResponseBody = {
instances?: {
instance?: [
{
instanceId?: string(name='InstanceId', example='hb-t4naqsay5gn****'),
instanceName?: string(name='InstanceName', example='name_test'),
isDefault?: boolean(name='IsDefault', example='false'),
}
](name='Instance')
}(name='Instances'),
requestId?: string(name='RequestId', example='89F81C30-320B-4550-91DB-C37C81D2358F'),
}
model ListHBaseInstancesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ListHBaseInstancesResponseBody(name='body'),
}
/**
* @param request ListHBaseInstancesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ListHBaseInstancesResponse
*/
async function listHBaseInstancesWithOptions(request: ListHBaseInstancesRequest, runtime: Util.RuntimeOptions): ListHBaseInstancesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ListHBaseInstances',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ListHBaseInstancesRequest
* @return ListHBaseInstancesResponse
*/
async function listHBaseInstances(request: ListHBaseInstancesRequest): ListHBaseInstancesResponse {
var runtime = new Util.RuntimeOptions{};
return listHBaseInstancesWithOptions(request, runtime);
}
model ListInstanceServiceConfigHistoriesRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
pageNumber?: int32(name='PageNumber', example='10'),
pageSize?: int32(name='PageSize', example='1'),
}
model ListInstanceServiceConfigHistoriesResponseBody = {
configureHistoryList?: {
config?: [
{
configureName?: string(name='ConfigureName', example='hbase#hbase-site.xml#hbase.client.keyvalue.maxsize'),
createTime?: string(name='CreateTime', example='1608708923000'),
effective?: string(name='Effective', example='false'),
newValue?: string(name='NewValue', example='10485770'),
oldValue?: string(name='OldValue', example='10485760'),
}
](name='Config')
}(name='ConfigureHistoryList'),
pageNumber?: int32(name='PageNumber', example='1'),
pageRecordCount?: int32(name='PageRecordCount', example='10'),
requestId?: string(name='RequestId', example='658C1549-2C02-4FD9-9490-EB3B285F9DCA'),
totalRecordCount?: long(name='TotalRecordCount', example='1'),
}
model ListInstanceServiceConfigHistoriesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ListInstanceServiceConfigHistoriesResponseBody(name='body'),
}
/**
* @param request ListInstanceServiceConfigHistoriesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ListInstanceServiceConfigHistoriesResponse
*/
async function listInstanceServiceConfigHistoriesWithOptions(request: ListInstanceServiceConfigHistoriesRequest, runtime: Util.RuntimeOptions): ListInstanceServiceConfigHistoriesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ListInstanceServiceConfigHistories',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ListInstanceServiceConfigHistoriesRequest
* @return ListInstanceServiceConfigHistoriesResponse
*/
async function listInstanceServiceConfigHistories(request: ListInstanceServiceConfigHistoriesRequest): ListInstanceServiceConfigHistoriesResponse {
var runtime = new Util.RuntimeOptions{};
return listInstanceServiceConfigHistoriesWithOptions(request, runtime);
}
model ListInstanceServiceConfigurationsRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
pageNumber?: int32(name='PageNumber', example='10'),
pageSize?: int32(name='PageSize', example='1'),
}
model ListInstanceServiceConfigurationsResponseBody = {
configureList?: {
config?: [
{
configureName?: string(name='ConfigureName', example='hbase#hbase-site.xml#hbase.client.keyvalue.maxsize'),
configureUnit?: string(name='ConfigureUnit', example='INT'),
defaultValue?: string(name='DefaultValue', example='10485760'),
description?: string(name='Description', example='hbase client keyvalue maxsize'),
needRestart?: string(name='NeedRestart', example='true'),
runningValue?: string(name='RunningValue', example='10485760'),
valueRange?: string(name='ValueRange', example='R[10485760,52428800]'),
}
](name='Config')
}(name='ConfigureList'),
pageNumber?: int32(name='PageNumber', example='1'),
pageRecordCount?: int32(name='PageRecordCount', example='10'),
requestId?: string(name='RequestId', example='5B381E36-BCA3-4377-8638-B65C236617D5'),
totalRecordCount?: long(name='TotalRecordCount', example='42'),
}
model ListInstanceServiceConfigurationsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ListInstanceServiceConfigurationsResponseBody(name='body'),
}
/**
* @param request ListInstanceServiceConfigurationsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ListInstanceServiceConfigurationsResponse
*/
async function listInstanceServiceConfigurationsWithOptions(request: ListInstanceServiceConfigurationsRequest, runtime: Util.RuntimeOptions): ListInstanceServiceConfigurationsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ListInstanceServiceConfigurations',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ListInstanceServiceConfigurationsRequest
* @return ListInstanceServiceConfigurationsResponse
*/
async function listInstanceServiceConfigurations(request: ListInstanceServiceConfigurationsRequest): ListInstanceServiceConfigurationsResponse {
var runtime = new Util.RuntimeOptions{};
return listInstanceServiceConfigurationsWithOptions(request, runtime);
}
model ListTagResourcesRequest {
nextToken?: string(name='NextToken', example='NextToken'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
resourceId?: [ string ](name='ResourceId', example='bds-bp15e022622f****'),
tag?: [
{
key?: string(name='Key', example='key1'),
value?: string(name='Value', example='value1'),
}
](name='Tag'),
}
model ListTagResourcesResponseBody = {
nextToken?: string(name='NextToken', example='1d2db86sca4384811e0b5e8707e68****'),
requestId?: string(name='RequestId', example='74F02441-9A8D-48F6-933F-E317AEB28DBF'),
tagResources?: {
tagResource?: [
{
resourceId?: string(name='ResourceId', example='bds-bp15e022622f****'),
resourceType?: string(name='ResourceType', example='ALIYUN::MULTIMOD::CLUSTER'),
tagKey?: string(name='TagKey', example='k1'),
tagValue?: string(name='TagValue', example='v2'),
}
](name='TagResource')
}(name='TagResources'),
}
model ListTagResourcesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ListTagResourcesResponseBody(name='body'),
}
/**
* @param request ListTagResourcesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ListTagResourcesResponse
*/
async function listTagResourcesWithOptions(request: ListTagResourcesRequest, runtime: Util.RuntimeOptions): ListTagResourcesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.nextToken)) {
query['NextToken'] = request.nextToken;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceId)) {
query['ResourceId'] = request.resourceId;
}
if (!Util.isUnset(request.tag)) {
query['Tag'] = request.tag;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ListTagResources',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ListTagResourcesRequest
* @return ListTagResourcesResponse
*/
async function listTagResources(request: ListTagResourcesRequest): ListTagResourcesResponse {
var runtime = new Util.RuntimeOptions{};
return listTagResourcesWithOptions(request, runtime);
}
model ListTagsRequest {
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-shanghai'),
}
model ListTagsResponseBody = {
requestId?: string(name='RequestId', example='36D1BE9B-3C4A-425B-947A-69E3D77999C4'),
tags?: {
tag?: [
{
tagKey?: string(name='TagKey', example='k1'),
tagValue?: string(name='TagValue', example='v2'),
}
](name='Tag')
}(name='Tags'),
}
model ListTagsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ListTagsResponseBody(name='body'),
}
/**
* @param request ListTagsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ListTagsResponse
*/
async function listTagsWithOptions(request: ListTagsRequest, runtime: Util.RuntimeOptions): ListTagsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ListTags',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ListTagsRequest
* @return ListTagsResponse
*/
async function listTags(request: ListTagsRequest): ListTagsResponse {
var runtime = new Util.RuntimeOptions{};
return listTagsWithOptions(request, runtime);
}
model ModifyAccountPasswordRequest {
accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
newAccountPassword?: string(name='NewAccountPassword', description='This parameter is required.', example='**********'),
}
model ModifyAccountPasswordResponseBody = {
requestId?: string(name='RequestId', example='AFAA617B-3268-5883-982B-DB8EC8CC1F1B'),
}
model ModifyAccountPasswordResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyAccountPasswordResponseBody(name='body'),
}
/**
* @summary 更改账户密码
*
* @param request ModifyAccountPasswordRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyAccountPasswordResponse
*/
async function modifyAccountPasswordWithOptions(request: ModifyAccountPasswordRequest, runtime: Util.RuntimeOptions): ModifyAccountPasswordResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.accountName)) {
query['AccountName'] = request.accountName;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.newAccountPassword)) {
query['NewAccountPassword'] = request.newAccountPassword;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyAccountPassword',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @summary 更改账户密码
*
* @param request ModifyAccountPasswordRequest
* @return ModifyAccountPasswordResponse
*/
async function modifyAccountPassword(request: ModifyAccountPasswordRequest): ModifyAccountPasswordResponse {
var runtime = new Util.RuntimeOptions{};
return modifyAccountPasswordWithOptions(request, runtime);
}
model ModifyActiveOperationTasksRequest {
ids?: string(name='Ids', description='This parameter is required.', example='1111,2222'),
immediateStart?: int32(name='ImmediateStart', example='1'),
ownerAccount?: string(name='OwnerAccount'),
ownerId?: long(name='OwnerId'),
resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
resourceOwnerId?: long(name='ResourceOwnerId'),
securityToken?: string(name='SecurityToken'),
switchTime?: string(name='SwitchTime', description='This parameter is required.', example='2022-02-17T18:50:00Z'),
}
model ModifyActiveOperationTasksResponseBody = {
ids?: string(name='Ids', example='1111,2222'),
requestId?: string(name='RequestId', example='8C9CC46A-9532-4752-B59F-580112C5A45B'),
}
model ModifyActiveOperationTasksResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyActiveOperationTasksResponseBody(name='body'),
}
/**
* @param request ModifyActiveOperationTasksRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyActiveOperationTasksResponse
*/
async function modifyActiveOperationTasksWithOptions(request: ModifyActiveOperationTasksRequest, runtime: Util.RuntimeOptions): ModifyActiveOperationTasksResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.ids)) {
query['Ids'] = request.ids;
}
if (!Util.isUnset(request.immediateStart)) {
query['ImmediateStart'] = request.immediateStart;
}
if (!Util.isUnset(request.ownerAccount)) {
query['OwnerAccount'] = request.ownerAccount;
}
if (!Util.isUnset(request.ownerId)) {
query['OwnerId'] = request.ownerId;
}
if (!Util.isUnset(request.resourceOwnerAccount)) {
query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
}
if (!Util.isUnset(request.resourceOwnerId)) {
query['ResourceOwnerId'] = request.resourceOwnerId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.switchTime)) {
query['SwitchTime'] = request.switchTime;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyActiveOperationTasks',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyActiveOperationTasksRequest
* @return ModifyActiveOperationTasksResponse
*/
async function modifyActiveOperationTasks(request: ModifyActiveOperationTasksRequest): ModifyActiveOperationTasksResponse {
var runtime = new Util.RuntimeOptions{};
return modifyActiveOperationTasksWithOptions(request, runtime);
}
model ModifyBackupPlanConfigRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
fullBackupCycle?: string(name='FullBackupCycle', description='This parameter is required.', example='7'),
minHFileBackupCount?: string(name='MinHFileBackupCount', description='This parameter is required.', example='3'),
nextFullBackupDate?: string(name='NextFullBackupDate', description='This parameter is required.', example='2020-11-09T18:00:00Z'),
tables?: string(name='Tables', description='This parameter is required.', example='*'),
}
model ModifyBackupPlanConfigResponseBody = {
requestId?: string(name='RequestId', example='50F4A8C2-076F-4703-9813-2FCD7FBB91C2'),
}
model ModifyBackupPlanConfigResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyBackupPlanConfigResponseBody(name='body'),
}
/**
* @param request ModifyBackupPlanConfigRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyBackupPlanConfigResponse
*/
async function modifyBackupPlanConfigWithOptions(request: ModifyBackupPlanConfigRequest, runtime: Util.RuntimeOptions): ModifyBackupPlanConfigResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.fullBackupCycle)) {
query['FullBackupCycle'] = request.fullBackupCycle;
}
if (!Util.isUnset(request.minHFileBackupCount)) {
query['MinHFileBackupCount'] = request.minHFileBackupCount;
}
if (!Util.isUnset(request.nextFullBackupDate)) {
query['NextFullBackupDate'] = request.nextFullBackupDate;
}
if (!Util.isUnset(request.tables)) {
query['Tables'] = request.tables;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyBackupPlanConfig',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyBackupPlanConfigRequest
* @return ModifyBackupPlanConfigResponse
*/
async function modifyBackupPlanConfig(request: ModifyBackupPlanConfigRequest): ModifyBackupPlanConfigResponse {
var runtime = new Util.RuntimeOptions{};
return modifyBackupPlanConfigWithOptions(request, runtime);
}
model ModifyBackupPolicyRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
preferredBackupEndTimeUTC?: string(name='PreferredBackupEndTimeUTC', example='18:00Z'),
preferredBackupPeriod?: string(name='PreferredBackupPeriod', description='This parameter is required.', example='Thursday'),
preferredBackupStartTimeUTC?: string(name='PreferredBackupStartTimeUTC', example='17:00Z'),
preferredBackupTime?: string(name='PreferredBackupTime', description='This parameter is required.', example='01:00-02:00'),
}
model ModifyBackupPolicyResponseBody = {
requestId?: string(name='RequestId', example='17E3AC63-300D-4B69-9108-45EC20E50E85'),
}
model ModifyBackupPolicyResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyBackupPolicyResponseBody(name='body'),
}
/**
* @param request ModifyBackupPolicyRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyBackupPolicyResponse
*/
async function modifyBackupPolicyWithOptions(request: ModifyBackupPolicyRequest, runtime: Util.RuntimeOptions): ModifyBackupPolicyResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.preferredBackupEndTimeUTC)) {
query['PreferredBackupEndTimeUTC'] = request.preferredBackupEndTimeUTC;
}
if (!Util.isUnset(request.preferredBackupPeriod)) {
query['PreferredBackupPeriod'] = request.preferredBackupPeriod;
}
if (!Util.isUnset(request.preferredBackupStartTimeUTC)) {
query['PreferredBackupStartTimeUTC'] = request.preferredBackupStartTimeUTC;
}
if (!Util.isUnset(request.preferredBackupTime)) {
query['PreferredBackupTime'] = request.preferredBackupTime;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyBackupPolicy',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyBackupPolicyRequest
* @return ModifyBackupPolicyResponse
*/
async function modifyBackupPolicy(request: ModifyBackupPolicyRequest): ModifyBackupPolicyResponse {
var runtime = new Util.RuntimeOptions{};
return modifyBackupPolicyWithOptions(request, runtime);
}
model ModifyClusterDeletionProtectionRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-****************'),
protection?: boolean(name='Protection', description='This parameter is required.', example='true'),
}
model ModifyClusterDeletionProtectionResponseBody = {
requestId?: string(name='RequestId', example='24C80BD8-C710-4138-893A-D2AFED4FC13D'),
}
model ModifyClusterDeletionProtectionResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyClusterDeletionProtectionResponseBody(name='body'),
}
/**
* @param request ModifyClusterDeletionProtectionRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyClusterDeletionProtectionResponse
*/
async function modifyClusterDeletionProtectionWithOptions(request: ModifyClusterDeletionProtectionRequest, runtime: Util.RuntimeOptions): ModifyClusterDeletionProtectionResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.protection)) {
query['Protection'] = request.protection;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyClusterDeletionProtection',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyClusterDeletionProtectionRequest
* @return ModifyClusterDeletionProtectionResponse
*/
async function modifyClusterDeletionProtection(request: ModifyClusterDeletionProtectionRequest): ModifyClusterDeletionProtectionResponse {
var runtime = new Util.RuntimeOptions{};
return modifyClusterDeletionProtectionWithOptions(request, runtime);
}
model ModifyDiskWarningLineRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
warningLine?: int32(name='WarningLine', description='This parameter is required.', example='80'),
}
model ModifyDiskWarningLineResponseBody = {
requestId?: string(name='RequestId', example='FC4A930D-3AEE-4C9D-BC70-C0F2EEEAA174'),
}
model ModifyDiskWarningLineResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyDiskWarningLineResponseBody(name='body'),
}
/**
* @param request ModifyDiskWarningLineRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyDiskWarningLineResponse
*/
async function modifyDiskWarningLineWithOptions(request: ModifyDiskWarningLineRequest, runtime: Util.RuntimeOptions): ModifyDiskWarningLineResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.warningLine)) {
query['WarningLine'] = request.warningLine;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyDiskWarningLine',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyDiskWarningLineRequest
* @return ModifyDiskWarningLineResponse
*/
async function modifyDiskWarningLine(request: ModifyDiskWarningLineRequest): ModifyDiskWarningLineResponse {
var runtime = new Util.RuntimeOptions{};
return modifyDiskWarningLineWithOptions(request, runtime);
}
model ModifyInstanceMaintainTimeRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp1b**6jco89****'),
maintainEndTime?: string(name='MaintainEndTime', description='This parameter is required.', example='06:00Z'),
maintainStartTime?: string(name='MaintainStartTime', description='This parameter is required.', example='02:00Z'),
}
model ModifyInstanceMaintainTimeResponseBody = {
requestId?: string(name='RequestId', example='C9085433-A56A-4089-B49A-DF5A4E2B7B06'),
}
model ModifyInstanceMaintainTimeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyInstanceMaintainTimeResponseBody(name='body'),
}
/**
* @param request ModifyInstanceMaintainTimeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyInstanceMaintainTimeResponse
*/
async function modifyInstanceMaintainTimeWithOptions(request: ModifyInstanceMaintainTimeRequest, runtime: Util.RuntimeOptions): ModifyInstanceMaintainTimeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.maintainEndTime)) {
query['MaintainEndTime'] = request.maintainEndTime;
}
if (!Util.isUnset(request.maintainStartTime)) {
query['MaintainStartTime'] = request.maintainStartTime;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyInstanceMaintainTime',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyInstanceMaintainTimeRequest
* @return ModifyInstanceMaintainTimeResponse
*/
async function modifyInstanceMaintainTime(request: ModifyInstanceMaintainTimeRequest): ModifyInstanceMaintainTimeResponse {
var runtime = new Util.RuntimeOptions{};
return modifyInstanceMaintainTimeWithOptions(request, runtime);
}
model ModifyInstanceNameRequest {
clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
clusterName?: string(name='ClusterName', description='This parameter is required.', example='testhbaseone'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}
model ModifyInstanceNameResponseBody = {
requestId?: string(name='RequestId', example='959DA199-54E5-569D-AD46-92BED8515E62'),
}
model ModifyInstanceNameResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyInstanceNameResponseBody(name='body'),
}
/**
* @param request ModifyInstanceNameRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyInstanceNameResponse
*/
async function modifyInstanceNameWithOptions(request: ModifyInstanceNameRequest, runtime: Util.RuntimeOptions): ModifyInstanceNameResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientToken)) {
query['ClientToken'] = request.clientToken;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.clusterName)) {
query['ClusterName'] = request.clusterName;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyInstanceName',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyInstanceNameRequest
* @return ModifyInstanceNameResponse
*/
async function modifyInstanceName(request: ModifyInstanceNameRequest): ModifyInstanceNameResponse {
var runtime = new Util.RuntimeOptions{};
return modifyInstanceNameWithOptions(request, runtime);
}
model ModifyInstanceServiceConfigRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
configureName?: string(name='ConfigureName', description='This parameter is required.', example='hbase#hbase-site.xml#hbase.client.keyvalue.maxsize'),
configureValue?: string(name='ConfigureValue', description='This parameter is required.', example='10485770'),
parameters?: string(name='Parameters', example='{"key1=value1", "key2=value2"}'),
restart?: boolean(name='Restart', example='false'),
}
model ModifyInstanceServiceConfigResponseBody = {
requestId?: string(name='RequestId', example='F008B7AB-025D-4C20-AE12-047C8F8C3D97'),
}
model ModifyInstanceServiceConfigResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyInstanceServiceConfigResponseBody(name='body'),
}
/**
* @param request ModifyInstanceServiceConfigRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyInstanceServiceConfigResponse
*/
async function modifyInstanceServiceConfigWithOptions(request: ModifyInstanceServiceConfigRequest, runtime: Util.RuntimeOptions): ModifyInstanceServiceConfigResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.configureName)) {
query['ConfigureName'] = request.configureName;
}
if (!Util.isUnset(request.configureValue)) {
query['ConfigureValue'] = request.configureValue;
}
if (!Util.isUnset(request.parameters)) {
query['Parameters'] = request.parameters;
}
if (!Util.isUnset(request.restart)) {
query['Restart'] = request.restart;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyInstanceServiceConfig',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyInstanceServiceConfigRequest
* @return ModifyInstanceServiceConfigResponse
*/
async function modifyInstanceServiceConfig(request: ModifyInstanceServiceConfigRequest): ModifyInstanceServiceConfigResponse {
var runtime = new Util.RuntimeOptions{};
return modifyInstanceServiceConfigWithOptions(request, runtime);
}
model ModifyInstanceTypeRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp1x940uh********'),
coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.8xlarge'),
masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.large'),
}
model ModifyInstanceTypeResponseBody = {
orderId?: string(name='OrderId', example='123412341234123'),
requestId?: string(name='RequestId', example='3E19E345-101D-4014-946C-****'),
}
model ModifyInstanceTypeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyInstanceTypeResponseBody(name='body'),
}
/**
* @param request ModifyInstanceTypeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyInstanceTypeResponse
*/
async function modifyInstanceTypeWithOptions(request: ModifyInstanceTypeRequest, runtime: Util.RuntimeOptions): ModifyInstanceTypeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.coreInstanceType)) {
query['CoreInstanceType'] = request.coreInstanceType;
}
if (!Util.isUnset(request.masterInstanceType)) {
query['MasterInstanceType'] = request.masterInstanceType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyInstanceType',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyInstanceTypeRequest
* @return ModifyInstanceTypeResponse
*/
async function modifyInstanceType(request: ModifyInstanceTypeRequest): ModifyInstanceTypeResponse {
var runtime = new Util.RuntimeOptions{};
return modifyInstanceTypeWithOptions(request, runtime);
}
model ModifyIpWhitelistRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp1uoihlf82e8****'),
groupName?: string(name='GroupName', description='This parameter is required.', example='group_01'),
ipList?: string(name='IpList', example='42.120.XX.XX'),
ipVersion?: string(name='IpVersion', description='This parameter is required.', example='4'),
}
model ModifyIpWhitelistResponseBody = {
requestId?: string(name='RequestId', example='101CFA8A-FB88-5014-A10C-3A0DA9AD8B0B'),
}
model ModifyIpWhitelistResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyIpWhitelistResponseBody(name='body'),
}
/**
* @param request ModifyIpWhitelistRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyIpWhitelistResponse
*/
async function modifyIpWhitelistWithOptions(request: ModifyIpWhitelistRequest, runtime: Util.RuntimeOptions): ModifyIpWhitelistResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.groupName)) {
query['GroupName'] = request.groupName;
}
if (!Util.isUnset(request.ipList)) {
query['IpList'] = request.ipList;
}
if (!Util.isUnset(request.ipVersion)) {
query['IpVersion'] = request.ipVersion;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyIpWhitelist',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyIpWhitelistRequest
* @return ModifyIpWhitelistResponse
*/
async function modifyIpWhitelist(request: ModifyIpWhitelistRequest): ModifyIpWhitelistResponse {
var runtime = new Util.RuntimeOptions{};
return modifyIpWhitelistWithOptions(request, runtime);
}
model ModifyMultiZoneClusterNodeTypeRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-dj45g7d6rbrd****'),
coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.large'),
logInstanceType?: string(name='LogInstanceType', example='hbase.sn1.2xlarge'),
masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.8xlarge'),
}
model ModifyMultiZoneClusterNodeTypeResponseBody = {
orderId?: string(name='OrderId', example='12341234123****'),
requestId?: string(name='RequestId', example='06CF7A6F-A81C-431D-BACD-793F24A67C54'),
}
model ModifyMultiZoneClusterNodeTypeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyMultiZoneClusterNodeTypeResponseBody(name='body'),
}
/**
* @param request ModifyMultiZoneClusterNodeTypeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyMultiZoneClusterNodeTypeResponse
*/
async function modifyMultiZoneClusterNodeTypeWithOptions(request: ModifyMultiZoneClusterNodeTypeRequest, runtime: Util.RuntimeOptions): ModifyMultiZoneClusterNodeTypeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.coreInstanceType)) {
query['CoreInstanceType'] = request.coreInstanceType;
}
if (!Util.isUnset(request.logInstanceType)) {
query['LogInstanceType'] = request.logInstanceType;
}
if (!Util.isUnset(request.masterInstanceType)) {
query['MasterInstanceType'] = request.masterInstanceType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyMultiZoneClusterNodeType',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyMultiZoneClusterNodeTypeRequest
* @return ModifyMultiZoneClusterNodeTypeResponse
*/
async function modifyMultiZoneClusterNodeType(request: ModifyMultiZoneClusterNodeTypeRequest): ModifyMultiZoneClusterNodeTypeResponse {
var runtime = new Util.RuntimeOptions{};
return modifyMultiZoneClusterNodeTypeWithOptions(request, runtime);
}
model ModifySecurityGroupsRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16f1441y6p2kv**'),
securityGroupIds?: string(name='SecurityGroupIds', description='This parameter is required.', example='sg-t4ng4yyc916o81nu****,sg-x4gg4dyc9d6w********'),
}
model ModifySecurityGroupsResponseBody = {
requestId?: string(name='RequestId', example='F4AD2E65-482B-46B6-942E-765989B1C8A3'),
}
model ModifySecurityGroupsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifySecurityGroupsResponseBody(name='body'),
}
/**
* @param request ModifySecurityGroupsRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifySecurityGroupsResponse
*/
async function modifySecurityGroupsWithOptions(request: ModifySecurityGroupsRequest, runtime: Util.RuntimeOptions): ModifySecurityGroupsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.securityGroupIds)) {
query['SecurityGroupIds'] = request.securityGroupIds;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifySecurityGroups',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifySecurityGroupsRequest
* @return ModifySecurityGroupsResponse
*/
async function modifySecurityGroups(request: ModifySecurityGroupsRequest): ModifySecurityGroupsResponse {
var runtime = new Util.RuntimeOptions{};
return modifySecurityGroupsWithOptions(request, runtime);
}
model ModifyUIAccountPasswordRequest {
accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
accountPassword?: string(name='AccountPassword', description='This parameter is required.', example='**********'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}
model ModifyUIAccountPasswordResponseBody = {
requestId?: string(name='RequestId', example='BED4ADEB-4EA9-507E-892C-84112D6AC7C1'),
}
model ModifyUIAccountPasswordResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyUIAccountPasswordResponseBody(name='body'),
}
/**
* @param request ModifyUIAccountPasswordRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ModifyUIAccountPasswordResponse
*/
async function modifyUIAccountPasswordWithOptions(request: ModifyUIAccountPasswordRequest, runtime: Util.RuntimeOptions): ModifyUIAccountPasswordResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.accountName)) {
query['AccountName'] = request.accountName;
}
if (!Util.isUnset(request.accountPassword)) {
query['AccountPassword'] = request.accountPassword;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyUIAccountPassword',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ModifyUIAccountPasswordRequest
* @return ModifyUIAccountPasswordResponse
*/
async function modifyUIAccountPassword(request: ModifyUIAccountPasswordRequest): ModifyUIAccountPasswordResponse {
var runtime = new Util.RuntimeOptions{};
return modifyUIAccountPasswordWithOptions(request, runtime);
}
model MoveResourceGroupRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp169l540vc6c****'),
newResourceGroupId?: string(name='NewResourceGroupId', description='This parameter is required.', example='rg-aekzrk6zzsy****'),
}
model MoveResourceGroupResponseBody = {
requestId?: string(name='RequestId', example='8CD9BFBC-D575-5FCC-BA7E-956BF0D0****'),
}
model MoveResourceGroupResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: MoveResourceGroupResponseBody(name='body'),
}
/**
* @param request MoveResourceGroupRequest
* @param runtime runtime options for this request RuntimeOptions
* @return MoveResourceGroupResponse
*/
async function moveResourceGroupWithOptions(request: MoveResourceGroupRequest, runtime: Util.RuntimeOptions): MoveResourceGroupResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.newResourceGroupId)) {
query['NewResourceGroupId'] = request.newResourceGroupId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'MoveResourceGroup',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request MoveResourceGroupRequest
* @return MoveResourceGroupResponse
*/
async function moveResourceGroup(request: MoveResourceGroupRequest): MoveResourceGroupResponse {
var runtime = new Util.RuntimeOptions{};
return moveResourceGroupWithOptions(request, runtime);
}
model OpenBackupRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
}
model OpenBackupResponseBody = {
requestId?: string(name='RequestId', example='C977DF60-7D06-4E34-A27D-8BC696C5112A'),
}
model OpenBackupResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: OpenBackupResponseBody(name='body'),
}
/**
* @param request OpenBackupRequest
* @param runtime runtime options for this request RuntimeOptions
* @return OpenBackupResponse
*/
async function openBackupWithOptions(request: OpenBackupRequest, runtime: Util.RuntimeOptions): OpenBackupResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'OpenBackup',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request OpenBackupRequest
* @return OpenBackupResponse
*/
async function openBackup(request: OpenBackupRequest): OpenBackupResponse {
var runtime = new Util.RuntimeOptions{};
return openBackupWithOptions(request, runtime);
}
model PurgeInstanceRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-m5ek15uzs7613xxxx'),
}
model PurgeInstanceResponseBody = {
requestId?: string(name='RequestId', example='276F899F-E952-496F-81B8-BD46D86854E3'),
}
model PurgeInstanceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: PurgeInstanceResponseBody(name='body'),
}
/**
* @param request PurgeInstanceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return PurgeInstanceResponse
*/
async function purgeInstanceWithOptions(request: PurgeInstanceRequest, runtime: Util.RuntimeOptions): PurgeInstanceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'PurgeInstance',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request PurgeInstanceRequest
* @return PurgeInstanceResponse
*/
async function purgeInstance(request: PurgeInstanceRequest): PurgeInstanceResponse {
var runtime = new Util.RuntimeOptions{};
return purgeInstanceWithOptions(request, runtime);
}
model QueryHBaseHaDBRequest {
bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-t4n3496whj23ia4k'),
}
model QueryHBaseHaDBResponseBody = {
clusterList?: {
cluster?: [
{
activeName?: string(name='ActiveName', example='hb-t4nn7dy1u1etbzmzm'),
bdsName?: string(name='BdsName', description='bdsId', example='bds-t4n3496whj23ia4k'),
haName?: string(name='HaName', example='ha-v21tmnxjwh2yuy1il'),
haSlbConnList?: {
haSlbConn?: [
{
hbaseType?: string(name='HbaseType', example='Standby'),
slbConnAddr?: string(name='SlbConnAddr', example='ha-v21tmnxjwh2yuy1il-phoenix.bds.9b78df04-b.rds.aliyuncs.com:8765'),
slbType?: string(name='SlbType', example='phoenix'),
}
](name='HaSlbConn')
}(name='HaSlbConnList'),
standbyName?: string(name='StandbyName', example='hb-t4n0ye37832tx22vz'),
}
](name='Cluster')
}(name='ClusterList'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='963355AD-A3B1-4654-AFFC-B5186EB8F889'),
totalCount?: long(name='TotalCount', example='1'),
}
model QueryHBaseHaDBResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: QueryHBaseHaDBResponseBody(name='body'),
}
/**
* @param request QueryHBaseHaDBRequest
* @param runtime runtime options for this request RuntimeOptions
* @return QueryHBaseHaDBResponse
*/
async function queryHBaseHaDBWithOptions(request: QueryHBaseHaDBRequest, runtime: Util.RuntimeOptions): QueryHBaseHaDBResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bdsId)) {
query['BdsId'] = request.bdsId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'QueryHBaseHaDB',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request QueryHBaseHaDBRequest
* @return QueryHBaseHaDBResponse
*/
async function queryHBaseHaDB(request: QueryHBaseHaDBRequest): QueryHBaseHaDBResponse {
var runtime = new Util.RuntimeOptions{};
return queryHBaseHaDBWithOptions(request, runtime);
}
model QueryXpackRelateDBRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ap-bp1qtz9rcbbt3p6ng'),
hasSingleNode?: boolean(name='HasSingleNode', example='false'),
relateDbType?: string(name='RelateDbType', description='This parameter is required.', example='hbase'),
}
model QueryXpackRelateDBResponseBody = {
clusterList?: {
cluster?: [
{
clusterId?: string(name='ClusterId', example='hb-bp16o0pd52e3y582s'),
clusterName?: string(name='ClusterName', example='hbase_test'),
DBType?: string(name='DBType', example='hbase'),
DBVersion?: string(name='DBVersion', example='2.0'),
isRelated?: boolean(name='IsRelated', example='false'),
lockMode?: string(name='LockMode', example='..'),
status?: string(name='Status', example='ACTIVATION'),
}
](name='Cluster')
}(name='ClusterList'),
requestId?: string(name='RequestId', example='288E9010-36DD-499C-B4DA-61E4362DA4CC'),
}
model QueryXpackRelateDBResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: QueryXpackRelateDBResponseBody(name='body'),
}
/**
* @param request QueryXpackRelateDBRequest
* @param runtime runtime options for this request RuntimeOptions
* @return QueryXpackRelateDBResponse
*/
async function queryXpackRelateDBWithOptions(request: QueryXpackRelateDBRequest, runtime: Util.RuntimeOptions): QueryXpackRelateDBResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.hasSingleNode)) {
query['HasSingleNode'] = request.hasSingleNode;
}
if (!Util.isUnset(request.relateDbType)) {
query['RelateDbType'] = request.relateDbType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'QueryXpackRelateDB',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request QueryXpackRelateDBRequest
* @return QueryXpackRelateDBResponse
*/
async function queryXpackRelateDB(request: QueryXpackRelateDBRequest): QueryXpackRelateDBResponse {
var runtime = new Util.RuntimeOptions{};
return queryXpackRelateDBWithOptions(request, runtime);
}
model RelateDbForHBaseHaRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='bds-t4nj9v2x85******'),
haActive?: string(name='HaActive', description='This parameter is required.', example='hb-bp1w6krp539******'),
haActiveClusterKey?: string(name='HaActiveClusterKey', example='hb-t4naqsay5gn******-master1-001.hbase.singapore.rds.aliyuncs.com,hb-t4naqsay5gn******-master3-001.hbase.singapore.rds.aliyuncs.com,hb-t4naqsay5gn******-master2-001.hbase.singapore.rds.aliyuncs.com:2181:/hbase'),
haActiveDBType?: string(name='HaActiveDBType', description='This parameter is required.', example='hbase'),
haActiveHbaseFsDir?: string(name='HaActiveHbaseFsDir', example='/hbase'),
haActiveHdfsUri?: string(name='HaActiveHdfsUri', example='hdfs://hb-t4naqsay5gn******-master1-001.hbase.rds.aliyuncs.com:8020,hb-t4naqsay5gn******-master2-001.hbase.rds.aliyuncs.com:8020'),
haActivePassword?: string(name='HaActivePassword', example='root'),
haActiveUser?: string(name='HaActiveUser', example='root'),
haActiveVersion?: string(name='HaActiveVersion', example='HBase2x'),
haMigrateType?: string(name='HaMigrateType', description='This parameter is required.', example='CLUSTER'),
haStandby?: string(name='HaStandby', description='This parameter is required.', example='hb-bp1bl7iqzka******'),
haStandbyClusterKey?: string(name='HaStandbyClusterKey', example='hb-bp1w6krp539******-master1-001.hbase.singapore.rds.aliyuncs.com,hb-bp1w6krp539******-master3-001.hbase.singapore.rds.aliyuncs.com,hb-t4naqsay5gn******-master2-001.hbase.singapore.rds.aliyuncs.com:2181:/hbase'),
haStandbyDBType?: string(name='HaStandbyDBType', description='This parameter is required.', example='hbase'),
haStandbyHbaseFsDir?: string(name='HaStandbyHbaseFsDir', example='/hbase'),
haStandbyHdfsUri?: string(name='HaStandbyHdfsUri', example='hdfs://hb-bp1w6krp539******-master1-001.hbase.rds.aliyuncs.com:8020,hb-bp1w6krp539******-master2-001.hbase.rds.aliyuncs.com:8020'),
haStandbyPassword?: string(name='HaStandbyPassword', example='root'),
haStandbyUser?: string(name='HaStandbyUser', example='root'),
haStandbyVersion?: string(name='HaStandbyVersion', example='HBase2x'),
haTables?: string(name='HaTables', example='test,test1'),
isActiveStandard?: boolean(name='IsActiveStandard', description='This parameter is required.', example='true'),
isStandbyStandard?: boolean(name='IsStandbyStandard', description='This parameter is required.', example='true'),
}
model RelateDbForHBaseHaResponseBody = {
requestId?: string(name='RequestId', example='DC654531-0799-4502-AFA5-80EE1C16829A'),
}
model RelateDbForHBaseHaResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: RelateDbForHBaseHaResponseBody(name='body'),
}
/**
* @param request RelateDbForHBaseHaRequest
* @param runtime runtime options for this request RuntimeOptions
* @return RelateDbForHBaseHaResponse
*/
async function relateDbForHBaseHaWithOptions(request: RelateDbForHBaseHaRequest, runtime: Util.RuntimeOptions): RelateDbForHBaseHaResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.haActive)) {
query['HaActive'] = request.haActive;
}
if (!Util.isUnset(request.haActiveClusterKey)) {
query['HaActiveClusterKey'] = request.haActiveClusterKey;
}
if (!Util.isUnset(request.haActiveDBType)) {
query['HaActiveDBType'] = request.haActiveDBType;
}
if (!Util.isUnset(request.haActiveHbaseFsDir)) {
query['HaActiveHbaseFsDir'] = request.haActiveHbaseFsDir;
}
if (!Util.isUnset(request.haActiveHdfsUri)) {
query['HaActiveHdfsUri'] = request.haActiveHdfsUri;
}
if (!Util.isUnset(request.haActivePassword)) {
query['HaActivePassword'] = request.haActivePassword;
}
if (!Util.isUnset(request.haActiveUser)) {
query['HaActiveUser'] = request.haActiveUser;
}
if (!Util.isUnset(request.haActiveVersion)) {
query['HaActiveVersion'] = request.haActiveVersion;
}
if (!Util.isUnset(request.haMigrateType)) {
query['HaMigrateType'] = request.haMigrateType;
}
if (!Util.isUnset(request.haStandby)) {
query['HaStandby'] = request.haStandby;
}
if (!Util.isUnset(request.haStandbyClusterKey)) {
query['HaStandbyClusterKey'] = request.haStandbyClusterKey;
}
if (!Util.isUnset(request.haStandbyDBType)) {
query['HaStandbyDBType'] = request.haStandbyDBType;
}
if (!Util.isUnset(request.haStandbyHbaseFsDir)) {
query['HaStandbyHbaseFsDir'] = request.haStandbyHbaseFsDir;
}
if (!Util.isUnset(request.haStandbyHdfsUri)) {
query['HaStandbyHdfsUri'] = request.haStandbyHdfsUri;
}
if (!Util.isUnset(request.haStandbyPassword)) {
query['HaStandbyPassword'] = request.haStandbyPassword;
}
if (!Util.isUnset(request.haStandbyUser)) {
query['HaStandbyUser'] = request.haStandbyUser;
}
if (!Util.isUnset(request.haStandbyVersion)) {
query['HaStandbyVersion'] = request.haStandbyVersion;
}
if (!Util.isUnset(request.haTables)) {
query['HaTables'] = request.haTables;
}
if (!Util.isUnset(request.isActiveStandard)) {
query['IsActiveStandard'] = request.isActiveStandard;
}
if (!Util.isUnset(request.isStandbyStandard)) {
query['IsStandbyStandard'] = request.isStandbyStandard;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'RelateDbForHBaseHa',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request RelateDbForHBaseHaRequest
* @return RelateDbForHBaseHaResponse
*/
async function relateDbForHBaseHa(request: RelateDbForHBaseHaRequest): RelateDbForHBaseHaResponse {
var runtime = new Util.RuntimeOptions{};
return relateDbForHBaseHaWithOptions(request, runtime);
}
model ReleasePublicNetworkAddressRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
}
model ReleasePublicNetworkAddressResponseBody = {
requestId?: string(name='RequestId', example='B18D4390-A968-4444-B323-4360B8E5DA3E'),
}
model ReleasePublicNetworkAddressResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ReleasePublicNetworkAddressResponseBody(name='body'),
}
/**
* @param request ReleasePublicNetworkAddressRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ReleasePublicNetworkAddressResponse
*/
async function releasePublicNetworkAddressWithOptions(request: ReleasePublicNetworkAddressRequest, runtime: Util.RuntimeOptions): ReleasePublicNetworkAddressResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ReleasePublicNetworkAddress',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ReleasePublicNetworkAddressRequest
* @return ReleasePublicNetworkAddressResponse
*/
async function releasePublicNetworkAddress(request: ReleasePublicNetworkAddressRequest): ReleasePublicNetworkAddressResponse {
var runtime = new Util.RuntimeOptions{};
return releasePublicNetworkAddressWithOptions(request, runtime);
}
model RenewInstanceRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp1u0639js2h7****'),
duration?: int32(name='Duration', description='This parameter is required.', example='5'),
pricingCycle?: string(name='PricingCycle', description='This parameter is required.', example='month'),
}
model RenewInstanceResponseBody = {
orderId?: long(name='OrderId', example='211235614240728'),
requestId?: string(name='RequestId', example='729CB2A7-3065-53A9-B27C-7033CA4881D9'),
}
model RenewInstanceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: RenewInstanceResponseBody(name='body'),
}
/**
* @param request RenewInstanceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return RenewInstanceResponse
*/
async function renewInstanceWithOptions(request: RenewInstanceRequest, runtime: Util.RuntimeOptions): RenewInstanceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.duration)) {
query['Duration'] = request.duration;
}
if (!Util.isUnset(request.pricingCycle)) {
query['PricingCycle'] = request.pricingCycle;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'RenewInstance',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request RenewInstanceRequest
* @return RenewInstanceResponse
*/
async function renewInstance(request: RenewInstanceRequest): RenewInstanceResponse {
var runtime = new Util.RuntimeOptions{};
return renewInstanceWithOptions(request, runtime);
}
model ResizeColdStorageSizeRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp169l540vc6c****'),
coldStorageSize?: int32(name='ColdStorageSize', description='This parameter is required.', example='900'),
}
model ResizeColdStorageSizeResponseBody = {
orderId?: string(name='OrderId', example='21711518427****'),
requestId?: string(name='RequestId', example='5AA6F80E-535C-5611-BD13-3832D96A4D0E'),
}
model ResizeColdStorageSizeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ResizeColdStorageSizeResponseBody(name='body'),
}
/**
* @param request ResizeColdStorageSizeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ResizeColdStorageSizeResponse
*/
async function resizeColdStorageSizeWithOptions(request: ResizeColdStorageSizeRequest, runtime: Util.RuntimeOptions): ResizeColdStorageSizeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.coldStorageSize)) {
query['ColdStorageSize'] = request.coldStorageSize;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ResizeColdStorageSize',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ResizeColdStorageSizeRequest
* @return ResizeColdStorageSizeResponse
*/
async function resizeColdStorageSize(request: ResizeColdStorageSizeRequest): ResizeColdStorageSizeResponse {
var runtime = new Util.RuntimeOptions{};
return resizeColdStorageSizeWithOptions(request, runtime);
}
model ResizeDiskSizeRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
nodeDiskSize?: int32(name='NodeDiskSize', description='This parameter is required.', example='120'),
}
model ResizeDiskSizeResponseBody = {
orderId?: string(name='OrderId', example='3C22622B-8555-42BF-AD8A-1B960743****'),
requestId?: string(name='RequestId', example='493A762B-E4A6-44E9-B877-CA6D0CAF8B29'),
}
model ResizeDiskSizeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ResizeDiskSizeResponseBody(name='body'),
}
/**
* @param request ResizeDiskSizeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ResizeDiskSizeResponse
*/
async function resizeDiskSizeWithOptions(request: ResizeDiskSizeRequest, runtime: Util.RuntimeOptions): ResizeDiskSizeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.nodeDiskSize)) {
query['NodeDiskSize'] = request.nodeDiskSize;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ResizeDiskSize',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ResizeDiskSizeRequest
* @return ResizeDiskSizeResponse
*/
async function resizeDiskSize(request: ResizeDiskSizeRequest): ResizeDiskSizeResponse {
var runtime = new Util.RuntimeOptions{};
return resizeDiskSizeWithOptions(request, runtime);
}
model ResizeMultiZoneClusterDiskSizeRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-f5d6vc2r8d6****'),
coreDiskSize?: int32(name='CoreDiskSize', example='480'),
logDiskSize?: int32(name='LogDiskSize', example='440'),
}
model ResizeMultiZoneClusterDiskSizeResponseBody = {
orderId?: string(name='OrderId', example='123412341****'),
requestId?: string(name='RequestId', example='568339C4-9F71-43D0-994E-E039CD826E56'),
}
model ResizeMultiZoneClusterDiskSizeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ResizeMultiZoneClusterDiskSizeResponseBody(name='body'),
}
/**
* @param request ResizeMultiZoneClusterDiskSizeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ResizeMultiZoneClusterDiskSizeResponse
*/
async function resizeMultiZoneClusterDiskSizeWithOptions(request: ResizeMultiZoneClusterDiskSizeRequest, runtime: Util.RuntimeOptions): ResizeMultiZoneClusterDiskSizeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.coreDiskSize)) {
query['CoreDiskSize'] = request.coreDiskSize;
}
if (!Util.isUnset(request.logDiskSize)) {
query['LogDiskSize'] = request.logDiskSize;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ResizeMultiZoneClusterDiskSize',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ResizeMultiZoneClusterDiskSizeRequest
* @return ResizeMultiZoneClusterDiskSizeResponse
*/
async function resizeMultiZoneClusterDiskSize(request: ResizeMultiZoneClusterDiskSizeRequest): ResizeMultiZoneClusterDiskSizeResponse {
var runtime = new Util.RuntimeOptions{};
return resizeMultiZoneClusterDiskSizeWithOptions(request, runtime);
}
model ResizeMultiZoneClusterNodeCountRequest {
arbiterVSwitchId?: string(name='ArbiterVSwitchId', example='vsw-hangxzhouxb*****'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-f5d8d6s4s2a1****'),
coreNodeCount?: int32(name='CoreNodeCount', example='6'),
logNodeCount?: int32(name='LogNodeCount', example='8'),
primaryCoreNodeCount?: int32(name='PrimaryCoreNodeCount', example='6'),
primaryVSwitchId?: string(name='PrimaryVSwitchId', example='vsw-hangxzhouxe*****'),
standbyCoreNodeCount?: int32(name='StandbyCoreNodeCount', example='6'),
standbyVSwitchId?: string(name='StandbyVSwitchId', example='vsw-hangxzhouxf****'),
}
model ResizeMultiZoneClusterNodeCountResponseBody = {
orderId?: string(name='OrderId', example='1234123412****'),
requestId?: string(name='RequestId', example='E2B7E9DA-1575-4B9D-A0E4-9468BAC'),
}
model ResizeMultiZoneClusterNodeCountResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ResizeMultiZoneClusterNodeCountResponseBody(name='body'),
}
/**
* @param request ResizeMultiZoneClusterNodeCountRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ResizeMultiZoneClusterNodeCountResponse
*/
async function resizeMultiZoneClusterNodeCountWithOptions(request: ResizeMultiZoneClusterNodeCountRequest, runtime: Util.RuntimeOptions): ResizeMultiZoneClusterNodeCountResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.arbiterVSwitchId)) {
query['ArbiterVSwitchId'] = request.arbiterVSwitchId;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.coreNodeCount)) {
query['CoreNodeCount'] = request.coreNodeCount;
}
if (!Util.isUnset(request.logNodeCount)) {
query['LogNodeCount'] = request.logNodeCount;
}
if (!Util.isUnset(request.primaryCoreNodeCount)) {
query['PrimaryCoreNodeCount'] = request.primaryCoreNodeCount;
}
if (!Util.isUnset(request.primaryVSwitchId)) {
query['PrimaryVSwitchId'] = request.primaryVSwitchId;
}
if (!Util.isUnset(request.standbyCoreNodeCount)) {
query['StandbyCoreNodeCount'] = request.standbyCoreNodeCount;
}
if (!Util.isUnset(request.standbyVSwitchId)) {
query['StandbyVSwitchId'] = request.standbyVSwitchId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ResizeMultiZoneClusterNodeCount',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ResizeMultiZoneClusterNodeCountRequest
* @return ResizeMultiZoneClusterNodeCountResponse
*/
async function resizeMultiZoneClusterNodeCount(request: ResizeMultiZoneClusterNodeCountRequest): ResizeMultiZoneClusterNodeCountResponse {
var runtime = new Util.RuntimeOptions{};
return resizeMultiZoneClusterNodeCountWithOptions(request, runtime);
}
model ResizeNodeCountRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
nodeCount?: int32(name='NodeCount', description='This parameter is required.', example='5'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp191otqj1ssyl****'),
zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}
model ResizeNodeCountResponseBody = {
orderId?: string(name='OrderId', example='20470860005****'),
requestId?: string(name='RequestId', example='B288B41F-6681-42A6-8905-47C3C42B19B0'),
}
model ResizeNodeCountResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ResizeNodeCountResponseBody(name='body'),
}
/**
* @param request ResizeNodeCountRequest
* @param runtime runtime options for this request RuntimeOptions
* @return ResizeNodeCountResponse
*/
async function resizeNodeCountWithOptions(request: ResizeNodeCountRequest, runtime: Util.RuntimeOptions): ResizeNodeCountResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.nodeCount)) {
query['NodeCount'] = request.nodeCount;
}
if (!Util.isUnset(request.vSwitchId)) {
query['VSwitchId'] = request.vSwitchId;
}
if (!Util.isUnset(request.zoneId)) {
query['ZoneId'] = request.zoneId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ResizeNodeCount',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request ResizeNodeCountRequest
* @return ResizeNodeCountResponse
*/
async function resizeNodeCount(request: ResizeNodeCountRequest): ResizeNodeCountResponse {
var runtime = new Util.RuntimeOptions{};
return resizeNodeCountWithOptions(request, runtime);
}
model RestartInstanceRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
components?: string(name='Components', example='THRIFT'),
}
model RestartInstanceResponseBody = {
requestId?: string(name='RequestId', example='F744E939-D08D-5623-82C8-9D1F9F7685D1'),
}
model RestartInstanceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: RestartInstanceResponseBody(name='body'),
}
/**
* @param request RestartInstanceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return RestartInstanceResponse
*/
async function restartInstanceWithOptions(request: RestartInstanceRequest, runtime: Util.RuntimeOptions): RestartInstanceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.components)) {
query['Components'] = request.components;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'RestartInstance',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request RestartInstanceRequest
* @return RestartInstanceResponse
*/
async function restartInstance(request: RestartInstanceRequest): RestartInstanceResponse {
var runtime = new Util.RuntimeOptions{};
return restartInstanceWithOptions(request, runtime);
}
model RevokeRequest {
accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
aclActions?: string(name='AclActions', description='This parameter is required.', example='READ,WRITE'),
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
namespace?: string(name='Namespace', description='This parameter is required.', example='default'),
tableName?: string(name='TableName', description='This parameter is required.', example='table'),
}
model RevokeResponseBody = {
requestId?: string(name='RequestId', example='C9085433-A56A-4089-B49A-DF5A4E2B7B06'),
}
model RevokeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: RevokeResponseBody(name='body'),
}
/**
* @summary 回收账户权限
*
* @param request RevokeRequest
* @param runtime runtime options for this request RuntimeOptions
* @return RevokeResponse
*/
async function revokeWithOptions(request: RevokeRequest, runtime: Util.RuntimeOptions): RevokeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.accountName)) {
query['AccountName'] = request.accountName;
}
if (!Util.isUnset(request.aclActions)) {
query['AclActions'] = request.aclActions;
}
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.namespace)) {
query['Namespace'] = request.namespace;
}
if (!Util.isUnset(request.tableName)) {
query['TableName'] = request.tableName;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'Revoke',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @summary 回收账户权限
*
* @param request RevokeRequest
* @return RevokeResponse
*/
async function revoke(request: RevokeRequest): RevokeResponse {
var runtime = new Util.RuntimeOptions{};
return revokeWithOptions(request, runtime);
}
model SwitchHbaseHaSlbRequest {
bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-t4n3496whj23ia4k'),
haId?: string(name='HaId', description='This parameter is required.', example='ha-v21tmnxjwh2yuy1il'),
haTypes?: string(name='HaTypes', description='This parameter is required.', example='thrift'),
hbaseType?: string(name='HbaseType', description='This parameter is required.', example='Active'),
}
model SwitchHbaseHaSlbResponseBody = {
requestId?: string(name='RequestId', example='C9D568D9-A59C-4AF2-8FBB-F086A841D58E'),
}
model SwitchHbaseHaSlbResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SwitchHbaseHaSlbResponseBody(name='body'),
}
/**
* @param request SwitchHbaseHaSlbRequest
* @param runtime runtime options for this request RuntimeOptions
* @return SwitchHbaseHaSlbResponse
*/
async function switchHbaseHaSlbWithOptions(request: SwitchHbaseHaSlbRequest, runtime: Util.RuntimeOptions): SwitchHbaseHaSlbResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bdsId)) {
query['BdsId'] = request.bdsId;
}
if (!Util.isUnset(request.haId)) {
query['HaId'] = request.haId;
}
if (!Util.isUnset(request.haTypes)) {
query['HaTypes'] = request.haTypes;
}
if (!Util.isUnset(request.hbaseType)) {
query['HbaseType'] = request.hbaseType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SwitchHbaseHaSlb',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request SwitchHbaseHaSlbRequest
* @return SwitchHbaseHaSlbResponse
*/
async function switchHbaseHaSlb(request: SwitchHbaseHaSlbRequest): SwitchHbaseHaSlbResponse {
var runtime = new Util.RuntimeOptions{};
return switchHbaseHaSlbWithOptions(request, runtime);
}
model SwitchServiceRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-uf6r2hn2zrxxxxxx'),
operate?: string(name='Operate', description='This parameter is required.', example='open'),
serviceName?: string(name='ServiceName', description='This parameter is required.', example='HBaseProxy'),
}
model SwitchServiceResponseBody = {
requestId?: string(name='RequestId', example='F1005DE4-D981-559F-9E37-5172DXXXXXX'),
}
model SwitchServiceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SwitchServiceResponseBody(name='body'),
}
/**
* @summary 开通/关闭 扩展服务
*
* @param request SwitchServiceRequest
* @param runtime runtime options for this request RuntimeOptions
* @return SwitchServiceResponse
*/
async function switchServiceWithOptions(request: SwitchServiceRequest, runtime: Util.RuntimeOptions): SwitchServiceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.operate)) {
query['Operate'] = request.operate;
}
if (!Util.isUnset(request.serviceName)) {
query['ServiceName'] = request.serviceName;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SwitchService',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @summary 开通/关闭 扩展服务
*
* @param request SwitchServiceRequest
* @return SwitchServiceResponse
*/
async function switchService(request: SwitchServiceRequest): SwitchServiceResponse {
var runtime = new Util.RuntimeOptions{};
return switchServiceWithOptions(request, runtime);
}
model TagResourcesRequest {
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
resourceId?: [ string ](name='ResourceId', description='This parameter is required.', example='bds-bp15e022622fk0w1'),
tag?: [
{
key?: string(name='Key', example='key1'),
value?: string(name='Value', example='value1'),
}
](name='Tag', description='This parameter is required.'),
}
model TagResourcesResponseBody = {
requestId?: string(name='RequestId', example='2656FA19-6059-40C8-A157-3FFBEAEC2369'),
}
model TagResourcesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: TagResourcesResponseBody(name='body'),
}
/**
* @param request TagResourcesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return TagResourcesResponse
*/
async function tagResourcesWithOptions(request: TagResourcesRequest, runtime: Util.RuntimeOptions): TagResourcesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceId)) {
query['ResourceId'] = request.resourceId;
}
if (!Util.isUnset(request.tag)) {
query['Tag'] = request.tag;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'TagResources',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request TagResourcesRequest
* @return TagResourcesResponse
*/
async function tagResources(request: TagResourcesRequest): TagResourcesResponse {
var runtime = new Util.RuntimeOptions{};
return tagResourcesWithOptions(request, runtime);
}
model UnTagResourcesRequest {
all?: boolean(name='All', example='true'),
regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
resourceId?: [ string ](name='ResourceId', description='This parameter is required.', example='bds-bp15e022622fk0w1'),
tagKey?: [ string ](name='TagKey', example='key1'),
}
model UnTagResourcesResponseBody = {
requestId?: string(name='RequestId', example='9CBF8DF0-4931-4A54-9B60-4C6E1AB59286'),
}
model UnTagResourcesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UnTagResourcesResponseBody(name='body'),
}
/**
* @param request UnTagResourcesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return UnTagResourcesResponse
*/
async function unTagResourcesWithOptions(request: UnTagResourcesRequest, runtime: Util.RuntimeOptions): UnTagResourcesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.all)) {
query['All'] = request.all;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceId)) {
query['ResourceId'] = request.resourceId;
}
if (!Util.isUnset(request.tagKey)) {
query['TagKey'] = request.tagKey;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UnTagResources',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request UnTagResourcesRequest
* @return UnTagResourcesResponse
*/
async function unTagResources(request: UnTagResourcesRequest): UnTagResourcesResponse {
var runtime = new Util.RuntimeOptions{};
return unTagResourcesWithOptions(request, runtime);
}
model UpgradeMinorVersionRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
components?: string(name='Components', example='HADOOP'),
}
model UpgradeMinorVersionResponseBody = {
requestId?: string(name='RequestId', example='7B8EC240-BB13-4DBC-B955-F90170E82609'),
upgradingComponents?: string(name='UpgradingComponents', example='HADOOP'),
}
model UpgradeMinorVersionResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UpgradeMinorVersionResponseBody(name='body'),
}
/**
* @param request UpgradeMinorVersionRequest
* @param runtime runtime options for this request RuntimeOptions
* @return UpgradeMinorVersionResponse
*/
async function upgradeMinorVersionWithOptions(request: UpgradeMinorVersionRequest, runtime: Util.RuntimeOptions): UpgradeMinorVersionResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.components)) {
query['Components'] = request.components;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UpgradeMinorVersion',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request UpgradeMinorVersionRequest
* @return UpgradeMinorVersionResponse
*/
async function upgradeMinorVersion(request: UpgradeMinorVersionRequest): UpgradeMinorVersionResponse {
var runtime = new Util.RuntimeOptions{};
return upgradeMinorVersionWithOptions(request, runtime);
}
model UpgradeMultiZoneClusterRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-***************'),
components?: string(name='Components', description='This parameter is required.', example='LINDORM'),
restartComponents?: string(name='RestartComponents', example='LPROXY'),
runMode?: string(name='RunMode', example='serial'),
upgradeInsName?: string(name='UpgradeInsName', example='ld-t4n40m3171t4******-az-b'),
versions?: string(name='Versions', example='t-apsara-lindorm-2.1.20-20200518175539.alios7.x86_64'),
}
model UpgradeMultiZoneClusterResponseBody = {
requestId?: string(name='RequestId', example='C532A4D4-9451-4460-BB3E-300FEC852D3F'),
upgradingComponents?: string(name='UpgradingComponents', example='LINDORM'),
}
model UpgradeMultiZoneClusterResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UpgradeMultiZoneClusterResponseBody(name='body'),
}
/**
* @param request UpgradeMultiZoneClusterRequest
* @param runtime runtime options for this request RuntimeOptions
* @return UpgradeMultiZoneClusterResponse
*/
async function upgradeMultiZoneClusterWithOptions(request: UpgradeMultiZoneClusterRequest, runtime: Util.RuntimeOptions): UpgradeMultiZoneClusterResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.components)) {
query['Components'] = request.components;
}
if (!Util.isUnset(request.restartComponents)) {
query['RestartComponents'] = request.restartComponents;
}
if (!Util.isUnset(request.runMode)) {
query['RunMode'] = request.runMode;
}
if (!Util.isUnset(request.upgradeInsName)) {
query['UpgradeInsName'] = request.upgradeInsName;
}
if (!Util.isUnset(request.versions)) {
query['Versions'] = request.versions;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UpgradeMultiZoneCluster',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request UpgradeMultiZoneClusterRequest
* @return UpgradeMultiZoneClusterResponse
*/
async function upgradeMultiZoneCluster(request: UpgradeMultiZoneClusterRequest): UpgradeMultiZoneClusterResponse {
var runtime = new Util.RuntimeOptions{};
return upgradeMultiZoneClusterWithOptions(request, runtime);
}
model XpackRelateDBRequest {
clusterId?: string(name='ClusterId', description='This parameter is required.', example='ap-bp1qtz9rcbbt3****'),
dbClusterIds?: string(name='DbClusterIds', description='This parameter is required.', example='hb-bp16o0pd52e3****'),
relateDbType?: string(name='RelateDbType', description='This parameter is required.', example='hbase'),
}
model XpackRelateDBResponseBody = {
requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}
model XpackRelateDBResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: XpackRelateDBResponseBody(name='body'),
}
/**
* @param request XpackRelateDBRequest
* @param runtime runtime options for this request RuntimeOptions
* @return XpackRelateDBResponse
*/
async function xpackRelateDBWithOptions(request: XpackRelateDBRequest, runtime: Util.RuntimeOptions): XpackRelateDBResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clusterId)) {
query['ClusterId'] = request.clusterId;
}
if (!Util.isUnset(request.dbClusterIds)) {
query['DbClusterIds'] = request.dbClusterIds;
}
if (!Util.isUnset(request.relateDbType)) {
query['RelateDbType'] = request.relateDbType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'XpackRelateDB',
version = '2019-01-01',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* @param request XpackRelateDBRequest
* @return XpackRelateDBResponse
*/
async function xpackRelateDB(request: XpackRelateDBRequest): XpackRelateDBResponse {
var runtime = new Util.RuntimeOptions{};
return xpackRelateDBWithOptions(request, runtime);
}