model

package
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 15, 2023 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AttrsObject 

type AttrsObject struct {

	// 缓存容量（G Byte）。
	Capacity *string `json:"capacity,omitempty"`

	// 额外信息名，取值范围如下： - sharding_num：该规格实例支持的分片数。 - proxy_num：该规格Proxy实例支持的Proxy节点数量。如果不是Proxy实例，该参数为0。 - db_number：该规格实例的DB数量。 - max_memory：实际可使用的最大内存。 - max_connections：该规格支持的最大连接数。 - max_clients：该规格支持的最大客户端数，一般等于最大连接数。 - max_bandwidth：该规格支持的最大带宽。 - max_in_bandwidth：该规格支持的最大接入带宽，一般等于最大带宽。
	Name *string `json:"name,omitempty"`

	// 额外信息值。
	Value *string `json:"value,omitempty"`
}

func (AttrsObject) String 

func (o AttrsObject) String() string

type AutoscanConfigRequest 

type AutoscanConfigRequest struct {

	// 是否开启自动分析
	EnableAutoScan bool `json:"enable_auto_scan"`

	// 每日分析时间，时间格式为21:00，时间为UTC时间
	ScheduleAt []string `json:"schedule_at"`
}

AutoscanConfigRequest 设置自动分析配置返回体

func (AutoscanConfigRequest) String 

func (o AutoscanConfigRequest) String() string

type AvailableZones 

type AvailableZones struct {

	// 可用区编码。
	Code *string `json:"code,omitempty"`

	// 可用区端口号。
	Port *string `json:"port,omitempty"`

	// 可用区名称。
	Name *string `json:"name,omitempty"`

	// 可用区ID。
	Id *string `json:"id,omitempty"`

	// 分区上是否还有可用资源。 - true：还有资源。 - false：资源已售罄。
	ResourceAvailability *AvailableZonesResourceAvailability `json:"resource_availability,omitempty"`
}

AvailableZones 可用分区结构体

func (AvailableZones) String 

func (o AvailableZones) String() string

type AvailableZonesResourceAvailability 

type AvailableZonesResourceAvailability struct {
	// contains filtered or unexported fields
}

func (AvailableZonesResourceAvailability) MarshalJSON 

func (c AvailableZonesResourceAvailability) MarshalJSON() ([]byte, error)

func (*AvailableZonesResourceAvailability) UnmarshalJSON 

func (c *AvailableZonesResourceAvailability) UnmarshalJSON(b []byte) error

func (AvailableZonesResourceAvailability) Value 

func (c AvailableZonesResourceAvailability) Value() string

type AvailableZonesResourceAvailabilityEnum 

type AvailableZonesResourceAvailabilityEnum struct {
	TRUE  AvailableZonesResourceAvailability
	FALSE AvailableZonesResourceAvailability
}

func GetAvailableZonesResourceAvailabilityEnum 

func GetAvailableZonesResourceAvailabilityEnum() AvailableZonesResourceAvailabilityEnum

type BackupFilesBody 

type BackupFilesBody struct {

	// 数据来源，当前仅支持OBS桶方式，取值为：self_build_obs。
	FileSource *BackupFilesBodyFileSource `json:"file_source,omitempty"`

	// OBS桶名。
	BucketName string `json:"bucket_name"`

	// 导入的备份文件文件列表。
	Files []Files `json:"files"`

	// 备份记录ID，数据来源为备份记录时必须填写
	BackupId *string `json:"backup_id,omitempty"`
}

BackupFilesBody 备份文件列表的结构体

func (BackupFilesBody) String 

func (o BackupFilesBody) String() string

type BackupFilesBodyFileSource 

type BackupFilesBodyFileSource struct {
	// contains filtered or unexported fields
}

func (BackupFilesBodyFileSource) MarshalJSON 

func (c BackupFilesBodyFileSource) MarshalJSON() ([]byte, error)

func (*BackupFilesBodyFileSource) UnmarshalJSON 

func (c *BackupFilesBodyFileSource) UnmarshalJSON(b []byte) error

func (BackupFilesBodyFileSource) Value 

func (c BackupFilesBodyFileSource) Value() string

type BackupFilesBodyFileSourceEnum 

type BackupFilesBodyFileSourceEnum struct {
	SELF_BUILD_OBS BackupFilesBodyFileSource
	BACKUP_RECORD  BackupFilesBodyFileSource
}

func GetBackupFilesBodyFileSourceEnum 

func GetBackupFilesBodyFileSourceEnum() BackupFilesBodyFileSourceEnum

type BackupInstanceBody 

type BackupInstanceBody struct {

	// 备份缓存实例的备注信息。
	Remark *string `json:"remark,omitempty"`

	// 备份缓存实例的格式。
	BackupFormat *BackupInstanceBodyBackupFormat `json:"backup_format,omitempty"`
}

BackupInstanceBody 备份实例请求体

func (BackupInstanceBody) String 

func (o BackupInstanceBody) String() string

type BackupInstanceBodyBackupFormat 

type BackupInstanceBodyBackupFormat struct {
	// contains filtered or unexported fields
}

func (BackupInstanceBodyBackupFormat) MarshalJSON 

func (c BackupInstanceBodyBackupFormat) MarshalJSON() ([]byte, error)

func (*BackupInstanceBodyBackupFormat) UnmarshalJSON 

func (c *BackupInstanceBodyBackupFormat) UnmarshalJSON(b []byte) error

func (BackupInstanceBodyBackupFormat) Value 

func (c BackupInstanceBodyBackupFormat) Value() string

type BackupInstanceBodyBackupFormatEnum 

type BackupInstanceBodyBackupFormatEnum struct {
	AOF BackupInstanceBodyBackupFormat
	RDB BackupInstanceBodyBackupFormat
}

func GetBackupInstanceBodyBackupFormatEnum 

func GetBackupInstanceBodyBackupFormatEnum() BackupInstanceBodyBackupFormatEnum

type BackupPlan 

type BackupPlan struct {

	// 备份的时区。取值为-1200 ~+1200之间的时区。若为空则默认使用DCS-Server节点的当前时区。
	TimezoneOffset *string `json:"timezone_offset,omitempty"`

	// 每周的周几开始备份，取值1-7，1代表周一，7代表周日。
	BackupAt []int32 `json:"backup_at"`

	// 备份周期类型，目前支持“weekly”。
	PeriodType string `json:"period_type"`

	// 备份执行时间，“00:00-01:00”代表0点开始执行备份。
	BeginAt string `json:"begin_at"`
}

func (BackupPlan) String 

func (o BackupPlan) String() string

type BackupPolicy 

type BackupPolicy struct {

	// 备份类型。 - auto：自动备份 - manual：手动备份
	BackupType string `json:"backup_type"`

	// 当backup_type设置为auto时，该参数为必填。 保留天数，单位：天，取值范围：1-7。
	SaveDays *int32 `json:"save_days,omitempty"`

	PeriodicalBackupPlan *BackupPlan `json:"periodical_backup_plan,omitempty"`
}

func (BackupPolicy) String 

func (o BackupPolicy) String() string

type BackupRecordResponse 

type BackupRecordResponse struct {

	// 备份记录ID。
	BackupId *string `json:"backup_id,omitempty"`

	// 备份执行时间段。
	Period *string `json:"period,omitempty"`

	// 备份记录名称。
	BackupName *string `json:"backup_name,omitempty"`

	// 实例ID。
	InstanceId *string `json:"instance_id,omitempty"`

	// 备份文件大小（Byte）。
	Size *int64 `json:"size,omitempty"`

	// 备份类型。 - manual：表示备份类型为手动备份 - auto：表示备份类型为自动备份
	BackupType *BackupRecordResponseBackupType `json:"backup_type,omitempty"`

	// 备份任务创建时间。
	CreatedAt *string `json:"created_at,omitempty"`

	// 备份完成时间。
	UpdatedAt *string `json:"updated_at,omitempty"`

	// 备份进度。
	Progress *string `json:"progress,omitempty"`

	// 备份失败后错误码 * `dcs.08.0001` - 启动备份恢复工具失败。 * `dcs.08.0002` - 执行超时。 * `dcs.08.0003` - 删除桶失败。 * `dcs.08.0004` - 获取ak/sk 失败。 * `dcs.08.0005` - 创建桶失败。 * `dcs.08.0006` - 查询备份数据大小失败。 * `dcs.08.0007` - 恢复时同步数据失败。 * `dcs.08.0008` - 自动备份任务未运行，实例正在运行其他任务。
	ErrorCode *string `json:"error_code,omitempty"`

	// 备份缓存实例的备注信息。
	Remark *string `json:"remark,omitempty"`

	// 备份状态。 - waiting：等待中。 - backuping：备份中。 - succeed：备份成功。 - failed：备份失败。 - expired：备份文件过期。 - deleted：已手动删除备份文件。
	Status *BackupRecordResponseStatus `json:"status,omitempty"`

	// 是否可以进行恢复操作，取值为TRUE或FALSE。
	IsSupportRestore *string `json:"is_support_restore,omitempty"`
}

BackupRecordResponse 实例备份信息。

func (BackupRecordResponse) String 

func (o BackupRecordResponse) String() string

type BackupRecordResponseBackupType 

type BackupRecordResponseBackupType struct {
	// contains filtered or unexported fields
}

func (BackupRecordResponseBackupType) MarshalJSON 

func (c BackupRecordResponseBackupType) MarshalJSON() ([]byte, error)

func (*BackupRecordResponseBackupType) UnmarshalJSON 

func (c *BackupRecordResponseBackupType) UnmarshalJSON(b []byte) error

func (BackupRecordResponseBackupType) Value 

func (c BackupRecordResponseBackupType) Value() string

type BackupRecordResponseBackupTypeEnum 

type BackupRecordResponseBackupTypeEnum struct {
	MANUAL BackupRecordResponseBackupType
	AUTO   BackupRecordResponseBackupType
}

func GetBackupRecordResponseBackupTypeEnum 

func GetBackupRecordResponseBackupTypeEnum() BackupRecordResponseBackupTypeEnum

type BackupRecordResponseStatus 

type BackupRecordResponseStatus struct {
	// contains filtered or unexported fields
}

func (BackupRecordResponseStatus) MarshalJSON 

func (c BackupRecordResponseStatus) MarshalJSON() ([]byte, error)

func (*BackupRecordResponseStatus) UnmarshalJSON 

func (c *BackupRecordResponseStatus) UnmarshalJSON(b []byte) error

func (BackupRecordResponseStatus) Value 

func (c BackupRecordResponseStatus) Value() string

type BackupRecordResponseStatusEnum 

type BackupRecordResponseStatusEnum struct {
	WAITING   BackupRecordResponseStatus
	BACKUPING BackupRecordResponseStatus
	SUCCEED   BackupRecordResponseStatus
	FAILED    BackupRecordResponseStatus
	EXPIRED   BackupRecordResponseStatus
	DELETED   BackupRecordResponseStatus
}

func GetBackupRecordResponseStatusEnum 

func GetBackupRecordResponseStatusEnum() BackupRecordResponseStatusEnum

type BandwidthInfo 

type BandwidthInfo struct {

	// 临时扩容开始时间
	BeginTime *int64 `json:"begin_time,omitempty"`

	// 临时扩容结束时间
	EndTime *int64 `json:"end_time,omitempty"`

	// 当前时间
	CurrentTime *int64 `json:"current_time,omitempty"`

	// 当前带宽，单位为GB
	Bandwidth *int32 `json:"bandwidth,omitempty"`

	// 下一个扩容时间
	NextExpandTime *int64 `json:"next_expand_time,omitempty"`

	// 扩容数量
	ExpandCount *int32 `json:"expand_count,omitempty"`

	// 临时扩容时间间隔
	ExpandEffectTime *int64 `json:"expand_effect_time,omitempty"`

	// 下一次可以扩容间隔时间
	ExpandIntervalTime *int64 `json:"expand_interval_time,omitempty"`

	// 最大扩容数量
	MaxExpandCount *int32 `json:"max_expand_count,omitempty"`

	// 任务是否运行
	TaskRunning *bool `json:"task_running,omitempty"`
}

func (BandwidthInfo) String 

func (o BandwidthInfo) String() string

type BatchCreateOrDeleteTagsRequest 

type BatchCreateOrDeleteTagsRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *CreateOrDeleteInstanceTags `json:"body,omitempty"`
}

BatchCreateOrDeleteTagsRequest Request Object

func (BatchCreateOrDeleteTagsRequest) String 

func (o BatchCreateOrDeleteTagsRequest) String() string

type BatchCreateOrDeleteTagsResponse 

type BatchCreateOrDeleteTagsResponse struct {
	HttpStatusCode int `json:"-"`
}

BatchCreateOrDeleteTagsResponse Response Object

func (BatchCreateOrDeleteTagsResponse) String 

func (o BatchCreateOrDeleteTagsResponse) String() string

type BatchDeleteBody 

type BatchDeleteBody struct {

	// 实例的ID列表。  仅当URI中参数all_failure值为“false”或者其他值时，才需要配置该参数。
	Instances *[]string `json:"instances,omitempty"`
}

func (BatchDeleteBody) String 

func (o BatchDeleteBody) String() string

type BatchDeleteInstancesRequest 

type BatchDeleteInstancesRequest struct {

	// 是否批量删除创建失败的缓存实例。取值如下： - true，表示删除租户所有创建失败的缓存实例，此时请求参数instances可为空； - false或者其他值，表示删除instances参数数组中指定的缓存实例。
	AllFailure *bool `json:"all_failure,omitempty"`

	Body *BatchDeleteBody `json:"body,omitempty"`
}

BatchDeleteInstancesRequest Request Object

func (BatchDeleteInstancesRequest) String 

func (o BatchDeleteInstancesRequest) String() string

type BatchDeleteInstancesResponse 

type BatchDeleteInstancesResponse struct {

	// 删除/重启/清空实例的结果。
	Results        *[]BatchOpsResult `json:"results,omitempty"`
	HttpStatusCode int               `json:"-"`
}

BatchDeleteInstancesResponse Response Object

func (BatchDeleteInstancesResponse) String 

func (o BatchDeleteInstancesResponse) String() string

type BatchOpsResult 

type BatchOpsResult struct {

	// 操作结果，取值有success或failed。
	Result *string `json:"result,omitempty"`

	// 缓存实例ID。
	Instance *string `json:"instance,omitempty"`
}

BatchOpsResult 批量删除实例接口返回结构体

func (BatchOpsResult) String 

func (o BatchOpsResult) String() string

type BatchShowNodesInformationRequest 

type BatchShowNodesInformationRequest struct {

	// 偏移量，表示从此偏移量开始查询，offset大于等于0。
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示的条目数量，当前最大值为100。若不设置该参数，则为10。
	Limit *int32 `json:"limit,omitempty"`
}

BatchShowNodesInformationRequest Request Object

func (BatchShowNodesInformationRequest) String 

func (o BatchShowNodesInformationRequest) String() string

type BatchShowNodesInformationResponse 

type BatchShowNodesInformationResponse struct {

	// 查询结果的实例总数
	Count *int32 `json:"count,omitempty"`

	// 实例列表。
	Instances      *[]InstanceNodesInfoResp `json:"instances,omitempty"`
	HttpStatusCode int                      `json:"-"`
}

BatchShowNodesInformationResponse Response Object

func (BatchShowNodesInformationResponse) String 

func (o BatchShowNodesInformationResponse) String() string

type BatchStopMigrationTasksBody 

type BatchStopMigrationTasksBody struct {

	// 数据迁移任务列表。
	MigrationTasks []string `json:"migration_tasks"`
}

BatchStopMigrationTasksBody 批量停止数据迁移任务结构体

func (BatchStopMigrationTasksBody) String 

func (o BatchStopMigrationTasksBody) String() string

type BatchStopMigrationTasksRequest 

type BatchStopMigrationTasksRequest struct {
	Body *BatchStopMigrationTasksBody `json:"body,omitempty"`
}

BatchStopMigrationTasksRequest Request Object

func (BatchStopMigrationTasksRequest) String 

func (o BatchStopMigrationTasksRequest) String() string

type BatchStopMigrationTasksResponse 

type BatchStopMigrationTasksResponse struct {

	// 数据迁移任务列表。
	MigrationTasks *[]StopMigrationTaskResult `json:"migration_tasks,omitempty"`
	HttpStatusCode int                        `json:"-"`
}

BatchStopMigrationTasksResponse Response Object

func (BatchStopMigrationTasksResponse) String 

func (o BatchStopMigrationTasksResponse) String() string

type BigkeysBody 

type BigkeysBody struct {

	// key名称
	Name *string `json:"name,omitempty"`

	// key类型
	Type *BigkeysBodyType `json:"type,omitempty"`

	// 大key所在的分片，仅在实例类型为集群时支持,格式为ip:port
	Shard *string `json:"shard,omitempty"`

	// 大key所在的db
	Db *int32 `json:"db,omitempty"`

	// key的value大小。
	Size *int64 `json:"size,omitempty"`

	// key大小的单位。type为string时，单位是：byte；type为list/set/zset/hash时，单位是：count
	Unit *string `json:"unit,omitempty"`
}

BigkeysBody 大key记录结构体

func (BigkeysBody) String 

func (o BigkeysBody) String() string

type BigkeysBodyType 

type BigkeysBodyType struct {
	// contains filtered or unexported fields
}

func (BigkeysBodyType) MarshalJSON 

func (c BigkeysBodyType) MarshalJSON() ([]byte, error)

func (*BigkeysBodyType) UnmarshalJSON 

func (c *BigkeysBodyType) UnmarshalJSON(b []byte) error

func (BigkeysBodyType) Value 

func (c BigkeysBodyType) Value() string

type BigkeysBodyTypeEnum 

type BigkeysBodyTypeEnum struct {
	STRING BigkeysBodyType
	LIST   BigkeysBodyType
	SET    BigkeysBodyType
	ZSET   BigkeysBodyType
	HASH   BigkeysBodyType
}

func GetBigkeysBodyTypeEnum 

func GetBigkeysBodyTypeEnum() BigkeysBodyTypeEnum

type BssParam 

type BssParam struct {

	// 当选择包年包月时，该字段为必选，表示是否自动续订资源。 取值范围： - false：不自动续订； - true：自动续订； 默认值为：false 约束： 如果设置为自动续订，到期后，会自动续订一个月（自动续订时间后续可能会变化），详情可联系客服咨询。
	IsAutoRenew *BssParamIsAutoRenew `json:"is_auto_renew,omitempty"`

	// 功能说明：付费方式（预付费、按需付费；预付费，即包周期付费）。 取值范围： - prePaid：预付费，即包年包月； - postPaid：后付费，即按需付费； 默认值是postPaid。 后付费的场景下，bss_param参数的其他字段都会被忽略。
	ChargingMode BssParamChargingMode `json:"charging_mode"`

	// 功能说明：下单订购后，是否自动从客户的账户中支付；默认是“不自动支付” 。  取值范围： - true：是（自动支付，从账户余额自动扣费） - false：否（默认值，只提交订单不支付，需要客户手动去支付）  约束： 自动支付时，只能使用账户的现金支付；如果要使用代金券，请选择不自动支付，然后在用户费用中心，选择代金券支付。  **如果没有设置成自动支付，即设置为false时，在创建实例之后，实例状态为“支付中”，用户必须在“费用中心 > 我的订单”，完成订单支付，否则订单一直在支付中，实例没有创建成功**。
	IsAutoPay *BssParamIsAutoPay `json:"is_auto_pay,omitempty"`

	// 当选择包年包月时，该字段为必选，表示订购资源的周期类型。  取值范围如下： - month：表示包月 - year：表示包年
	PeriodType *BssParamPeriodType `json:"period_type,omitempty"`

	// 功能说明：订购周期数 取值范围：(后续会随运营策略变化) - period_type为month时，为[1,9]， - period_type为year时，为[1,3]  约束：同period_type约束。
	PeriodNum *int32 `json:"period_num,omitempty"`
}

func (BssParam) String 

func (o BssParam) String() string

type BssParamChargingMode 

type BssParamChargingMode struct {
	// contains filtered or unexported fields
}

func (BssParamChargingMode) MarshalJSON 

func (c BssParamChargingMode) MarshalJSON() ([]byte, error)

func (*BssParamChargingMode) UnmarshalJSON 

func (c *BssParamChargingMode) UnmarshalJSON(b []byte) error

func (BssParamChargingMode) Value 

func (c BssParamChargingMode) Value() string

type BssParamChargingModeEnum 

type BssParamChargingModeEnum struct {
	PRE_PAID  BssParamChargingMode
	POST_PAID BssParamChargingMode
}

func GetBssParamChargingModeEnum 

func GetBssParamChargingModeEnum() BssParamChargingModeEnum

type BssParamEntity 

type BssParamEntity struct {

	// 功能说明：下单订购后，是否自动从客户的账户中支付；默认是“不自动支付” 。  取值范围： - true：是（自动支付，从账户余额自动扣费） - false：否（默认值，只提交订单不支付，需要客户手动去支付）  约束： 自动支付时，只能使用账户的现金支付；如果要使用代金券，请选择不自动支付，然后在用户费用中心，选择代金券支付。  **如果没有设置成自动支付，即设置为false时，在创建实例之后，实例状态为“支付中”，用户必须在“费用中心 > 我的订单”，完成订单支付，否则订单一直在支付中，实例没有创建成功**。
	IsAutoPay *BssParamEntityIsAutoPay `json:"is_auto_pay,omitempty"`
}

func (BssParamEntity) String 

func (o BssParamEntity) String() string

type BssParamEntityIsAutoPay 

type BssParamEntityIsAutoPay struct {
	// contains filtered or unexported fields
}

func (BssParamEntityIsAutoPay) MarshalJSON 

func (c BssParamEntityIsAutoPay) MarshalJSON() ([]byte, error)

func (*BssParamEntityIsAutoPay) UnmarshalJSON 

func (c *BssParamEntityIsAutoPay) UnmarshalJSON(b []byte) error

func (BssParamEntityIsAutoPay) Value 

func (c BssParamEntityIsAutoPay) Value() string

type BssParamEntityIsAutoPayEnum 

type BssParamEntityIsAutoPayEnum struct {
	TRUE  BssParamEntityIsAutoPay
	FALSE BssParamEntityIsAutoPay
}

func GetBssParamEntityIsAutoPayEnum 

func GetBssParamEntityIsAutoPayEnum() BssParamEntityIsAutoPayEnum

type BssParamIsAutoPay 

type BssParamIsAutoPay struct {
	// contains filtered or unexported fields
}

func (BssParamIsAutoPay) MarshalJSON 

func (c BssParamIsAutoPay) MarshalJSON() ([]byte, error)

func (*BssParamIsAutoPay) UnmarshalJSON 

func (c *BssParamIsAutoPay) UnmarshalJSON(b []byte) error

func (BssParamIsAutoPay) Value 

func (c BssParamIsAutoPay) Value() string

type BssParamIsAutoPayEnum 

type BssParamIsAutoPayEnum struct {
	TRUE  BssParamIsAutoPay
	FALSE BssParamIsAutoPay
}

func GetBssParamIsAutoPayEnum 

func GetBssParamIsAutoPayEnum() BssParamIsAutoPayEnum

type BssParamIsAutoRenew 

type BssParamIsAutoRenew struct {
	// contains filtered or unexported fields
}

func (BssParamIsAutoRenew) MarshalJSON 

func (c BssParamIsAutoRenew) MarshalJSON() ([]byte, error)

func (*BssParamIsAutoRenew) UnmarshalJSON 

func (c *BssParamIsAutoRenew) UnmarshalJSON(b []byte) error

func (BssParamIsAutoRenew) Value 

func (c BssParamIsAutoRenew) Value() string

type BssParamIsAutoRenewEnum 

type BssParamIsAutoRenewEnum struct {
	TRUE  BssParamIsAutoRenew
	FALSE BssParamIsAutoRenew
}

func GetBssParamIsAutoRenewEnum 

func GetBssParamIsAutoRenewEnum() BssParamIsAutoRenewEnum

type BssParamPeriodType 

type BssParamPeriodType struct {
	// contains filtered or unexported fields
}

func (BssParamPeriodType) MarshalJSON 

func (c BssParamPeriodType) MarshalJSON() ([]byte, error)

func (*BssParamPeriodType) UnmarshalJSON 

func (c *BssParamPeriodType) UnmarshalJSON(b []byte) error

func (BssParamPeriodType) Value 

func (c BssParamPeriodType) Value() string

type BssParamPeriodTypeEnum 

type BssParamPeriodTypeEnum struct {
	MONTH BssParamPeriodType
	YEAR  BssParamPeriodType
}

func GetBssParamPeriodTypeEnum 

func GetBssParamPeriodTypeEnum() BssParamPeriodTypeEnum

type ChangeInstanceStatusBody 

type ChangeInstanceStatusBody struct {

	// 实例的ID列表。
	Instances *[]string `json:"instances,omitempty"`

	// 对实例的操作：  restart: 强制重启  soft_restart: 软重启，只重启进程  flush: 清空数据 > 当前版本，只有Redis 4.0和Redis 5.0实例支持清空数据功能，即flush操作。
	Action *string `json:"action,omitempty"`
}

ChangeInstanceStatusBody 重启、清空实例数据的请求体

func (ChangeInstanceStatusBody) String 

func (o ChangeInstanceStatusBody) String() string

type ChangeMasterStandbyRequest 

type ChangeMasterStandbyRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

ChangeMasterStandbyRequest Request Object

func (ChangeMasterStandbyRequest) String 

func (o ChangeMasterStandbyRequest) String() string

type ChangeMasterStandbyResponse 

type ChangeMasterStandbyResponse struct {
	HttpStatusCode int `json:"-"`
}

ChangeMasterStandbyResponse Response Object

func (ChangeMasterStandbyResponse) String 

func (o ChangeMasterStandbyResponse) String() string

type ClusterRedisNodeMonitoredObject 

type ClusterRedisNodeMonitoredObject struct {

	// 测量对象ID，即节点的ID。
	DcsInstanceId *string `json:"dcs_instance_id,omitempty"`

	// 测量对象名称，即节点IP。
	Name *string `json:"name,omitempty"`

	// 维度dcs_cluster_redis_node的测量对象的ID。
	DcsClusterRedisNode *string `json:"dcs_cluster_redis_node,omitempty"`

	// 测量对象状态，即节点状态。
	Status *string `json:"status,omitempty"`
}

ClusterRedisNodeMonitoredObject 监控对象结构

func (ClusterRedisNodeMonitoredObject) String 

func (o ClusterRedisNodeMonitoredObject) String() string

type CommandTimeTaken 

type CommandTimeTaken struct {

	// 调用次数
	CallsSum int32 `json:"calls_sum"`

	// 耗时总数
	UsecSum float64 `json:"usec_sum"`

	// 命令名称
	CommandName string `json:"command_name"`

	// 耗时占比
	PerUsec string `json:"per_usec"`

	// 每次调用平均耗时
	AverageUsec float64 `json:"average_usec"`
}

CommandTimeTaken 命令耗时统计

func (CommandTimeTaken) String 

func (o CommandTimeTaken) String() string

type CommandTimeTakenList 

type CommandTimeTakenList struct {

	// 执行命令的总次数
	TotalNum int32 `json:"total_num"`

	// 执行命令的总耗时
	TotalUsecSum float64 `json:"total_usec_sum"`

	// 命令耗时统计结果
	Result CommandTimeTakenListResult `json:"result"`

	// 命令耗时统计
	CommandList []CommandTimeTaken `json:"command_list"`
}

CommandTimeTakenList 命令耗时统计列表

func (CommandTimeTakenList) String 

func (o CommandTimeTakenList) String() string

type CommandTimeTakenListResult 

type CommandTimeTakenListResult struct {
	// contains filtered or unexported fields
}

func (CommandTimeTakenListResult) MarshalJSON 

func (c CommandTimeTakenListResult) MarshalJSON() ([]byte, error)

func (*CommandTimeTakenListResult) UnmarshalJSON 

func (c *CommandTimeTakenListResult) UnmarshalJSON(b []byte) error

func (CommandTimeTakenListResult) Value 

func (c CommandTimeTakenListResult) Value() string

type CommandTimeTakenListResultEnum 

type CommandTimeTakenListResultEnum struct {
	SUCCEED CommandTimeTakenListResult
	FAILED  CommandTimeTakenListResult
}

func GetCommandTimeTakenListResultEnum 

func GetCommandTimeTakenListResultEnum() CommandTimeTakenListResultEnum

type ConclusionItem 

type ConclusionItem struct {

	// 结论id
	Id int32 `json:"id"`

	// 结论参数
	Params map[string]string `json:"params,omitempty"`
}

ConclusionItem 诊断结论

func (ConclusionItem) String 

func (o ConclusionItem) String() string

type ConfigMigrationInstanceBody 

type ConfigMigrationInstanceBody struct {

	// Redis实例ID。（Redis类型为云服务Redis时必须填写）
	Id *string `json:"id,omitempty"`

	// Redis实例地址。（Redis类型为自建Redis时必须填写）。
	Addrs *string `json:"addrs,omitempty"`

	// Redis密码，如果设置了密码，则必须填写。
	Password *string `json:"password,omitempty"`
}

ConfigMigrationInstanceBody 迁移任务实例信息

func (ConfigMigrationInstanceBody) String 

func (o ConfigMigrationInstanceBody) String() string

type ConfigTemplatesListInfo 

type ConfigTemplatesListInfo struct {

	// 模板ID
	TemplateId *string `json:"template_id,omitempty"`

	// 缓存实例类型。取值范围如下： - single：表示单机实例 - ha：表示主备实例 - cluster：表示cluster集群实例 - proxy：表示Proxy集群实例 [- ha_rw_split： 表示读写分离实例](tag:hws)
	CacheMode *string `json:"cache_mode,omitempty"`

	// 模板的描述信息
	Description *string `json:"description,omitempty"`

	// 缓存引擎：Redis[和Memcached](tag:hws,hws_hk,ocb,sbc,tm,ctc,cmcc)。
	Engine *string `json:"engine,omitempty"`

	// 缓存版本。  当缓存引擎为Redis时，取值为4.0或5.0。  [当缓存引擎为Memcached时，该字段为可选，取值为空。](tag:hws,hws_hk,ocb,sbc,tm,ctc,cmcc)
	EngineVersion *string `json:"engine_version,omitempty"`

	// 模板名称
	Name *string `json:"name,omitempty"`

	// 产品类型。 取值范围如下： - generic：普通版 - enterprise：企业版
	ProductType *ConfigTemplatesListInfoProductType `json:"product_type,omitempty"`

	// 存储类型。 取值范围如下： - DRAM - SSD
	StorageType *ConfigTemplatesListInfoStorageType `json:"storage_type,omitempty"`

	// 模板类型
	Type *string `json:"type,omitempty"`

	// 模板创建时间，仅在自定义参数模板中有意义，格式例如：2023-05-10T11:09:35.802Z
	CreatedAt *string `json:"created_at,omitempty"`
}

func (ConfigTemplatesListInfo) String 

func (o ConfigTemplatesListInfo) String() string

type ConfigTemplatesListInfoProductType 

type ConfigTemplatesListInfoProductType struct {
	// contains filtered or unexported fields
}

func (ConfigTemplatesListInfoProductType) MarshalJSON 

func (c ConfigTemplatesListInfoProductType) MarshalJSON() ([]byte, error)

func (*ConfigTemplatesListInfoProductType) UnmarshalJSON 

func (c *ConfigTemplatesListInfoProductType) UnmarshalJSON(b []byte) error

func (ConfigTemplatesListInfoProductType) Value 

func (c ConfigTemplatesListInfoProductType) Value() string

type ConfigTemplatesListInfoProductTypeEnum 

type ConfigTemplatesListInfoProductTypeEnum struct {
	GENERIC    ConfigTemplatesListInfoProductType
	ENTERPRISE ConfigTemplatesListInfoProductType
}

func GetConfigTemplatesListInfoProductTypeEnum 

func GetConfigTemplatesListInfoProductTypeEnum() ConfigTemplatesListInfoProductTypeEnum

type ConfigTemplatesListInfoStorageType 

type ConfigTemplatesListInfoStorageType struct {
	// contains filtered or unexported fields
}

func (ConfigTemplatesListInfoStorageType) MarshalJSON 

func (c ConfigTemplatesListInfoStorageType) MarshalJSON() ([]byte, error)

func (*ConfigTemplatesListInfoStorageType) UnmarshalJSON 

func (c *ConfigTemplatesListInfoStorageType) UnmarshalJSON(b []byte) error

func (ConfigTemplatesListInfoStorageType) Value 

func (c ConfigTemplatesListInfoStorageType) Value() string

type ConfigTemplatesListInfoStorageTypeEnum 

type ConfigTemplatesListInfoStorageTypeEnum struct {
	DRAM ConfigTemplatesListInfoStorageType
	SSD  ConfigTemplatesListInfoStorageType
}

func GetConfigTemplatesListInfoStorageTypeEnum 

func GetConfigTemplatesListInfoStorageTypeEnum() ConfigTemplatesListInfoStorageTypeEnum

type CopyInstanceRequest 

type CopyInstanceRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *BackupInstanceBody `json:"body,omitempty"`
}

CopyInstanceRequest Request Object

func (CopyInstanceRequest) String 

func (o CopyInstanceRequest) String() string

type CopyInstanceResponse 

type CopyInstanceResponse struct {

	// 备份记录ID。
	BackupId       *string `json:"backup_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CopyInstanceResponse Response Object

func (CopyInstanceResponse) String 

func (o CopyInstanceResponse) String() string

type CreateAutoExpireScanTaskRequest 

type CreateAutoExpireScanTaskRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

CreateAutoExpireScanTaskRequest Request Object

func (CreateAutoExpireScanTaskRequest) String 

func (o CreateAutoExpireScanTaskRequest) String() string

type CreateAutoExpireScanTaskResponse 

type CreateAutoExpireScanTaskResponse struct {

	// 过期key扫描记录ID
	Id *string `json:"id,omitempty"`

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 扫描任务状态
	Status *CreateAutoExpireScanTaskResponseStatus `json:"status,omitempty"`

	// 扫描方式
	ScanType *CreateAutoExpireScanTaskResponseScanType `json:"scan_type,omitempty"`

	// 扫描任务创建时间,格式为：\"2020-06-15T02:21:18.669Z\"
	CreatedAt *string `json:"created_at,omitempty"`

	// 扫描任务开始时间,格式为：\"2020-06-15T02:21:18.669Z\"（创建扫描任务时此值为null，不返回）
	StartedAt *string `json:"started_at,omitempty"`

	// 扫描任务结束时间,格式为：\"2020-06-15T02:21:18.669Z\"（创建扫描任务时此值为null，不返回）
	FinishedAt     *string `json:"finished_at,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CreateAutoExpireScanTaskResponse Response Object

func (CreateAutoExpireScanTaskResponse) String 

func (o CreateAutoExpireScanTaskResponse) String() string

type CreateAutoExpireScanTaskResponseScanType 

type CreateAutoExpireScanTaskResponseScanType struct {
	// contains filtered or unexported fields
}

func (CreateAutoExpireScanTaskResponseScanType) MarshalJSON 

func (c CreateAutoExpireScanTaskResponseScanType) MarshalJSON() ([]byte, error)

func (*CreateAutoExpireScanTaskResponseScanType) UnmarshalJSON 

func (c *CreateAutoExpireScanTaskResponseScanType) UnmarshalJSON(b []byte) error

func (CreateAutoExpireScanTaskResponseScanType) Value 

func (c CreateAutoExpireScanTaskResponseScanType) Value() string

type CreateAutoExpireScanTaskResponseScanTypeEnum 

type CreateAutoExpireScanTaskResponseScanTypeEnum struct {
	MANUAL CreateAutoExpireScanTaskResponseScanType
	AUTO   CreateAutoExpireScanTaskResponseScanType
}

func GetCreateAutoExpireScanTaskResponseScanTypeEnum 

func GetCreateAutoExpireScanTaskResponseScanTypeEnum() CreateAutoExpireScanTaskResponseScanTypeEnum

type CreateAutoExpireScanTaskResponseStatus 

type CreateAutoExpireScanTaskResponseStatus struct {
	// contains filtered or unexported fields
}

func (CreateAutoExpireScanTaskResponseStatus) MarshalJSON 

func (c CreateAutoExpireScanTaskResponseStatus) MarshalJSON() ([]byte, error)

func (*CreateAutoExpireScanTaskResponseStatus) UnmarshalJSON 

func (c *CreateAutoExpireScanTaskResponseStatus) UnmarshalJSON(b []byte) error

func (CreateAutoExpireScanTaskResponseStatus) Value 

func (c CreateAutoExpireScanTaskResponseStatus) Value() string

type CreateAutoExpireScanTaskResponseStatusEnum 

type CreateAutoExpireScanTaskResponseStatusEnum struct {
	WAITING CreateAutoExpireScanTaskResponseStatus
	RUNNING CreateAutoExpireScanTaskResponseStatus
	SUCCESS CreateAutoExpireScanTaskResponseStatus
	FAILED  CreateAutoExpireScanTaskResponseStatus
}

func GetCreateAutoExpireScanTaskResponseStatusEnum 

func GetCreateAutoExpireScanTaskResponseStatusEnum() CreateAutoExpireScanTaskResponseStatusEnum

type CreateBigkeyScanTaskRequest 

type CreateBigkeyScanTaskRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

CreateBigkeyScanTaskRequest Request Object

func (CreateBigkeyScanTaskRequest) String 

func (o CreateBigkeyScanTaskRequest) String() string

type CreateBigkeyScanTaskResponse 

type CreateBigkeyScanTaskResponse struct {

	// 大key分析记录ID
	Id *string `json:"id,omitempty"`

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 分析任务状态
	Status *CreateBigkeyScanTaskResponseStatus `json:"status,omitempty"`

	// 分析方式
	ScanType *CreateBigkeyScanTaskResponseScanType `json:"scan_type,omitempty"`

	// 分析任务创建时间,格式为：\"2020-06-15T02:21:18.669Z\"
	CreatedAt *string `json:"created_at,omitempty"`

	// 分析任务开始时间,格式为：\"2020-06-15T02:21:18.669Z\"
	StartedAt *string `json:"started_at,omitempty"`

	// 分析任务结束时间,格式为：\"2020-06-15T02:21:18.669Z\"
	FinishedAt *string `json:"finished_at,omitempty"`

	// 大key的数量
	Num *int32 `json:"num,omitempty"`

	// 大key记录
	Keys           *[]BigkeysBody `json:"keys,omitempty"`
	HttpStatusCode int            `json:"-"`
}

CreateBigkeyScanTaskResponse Response Object

func (CreateBigkeyScanTaskResponse) String 

func (o CreateBigkeyScanTaskResponse) String() string

type CreateBigkeyScanTaskResponseScanType 

type CreateBigkeyScanTaskResponseScanType struct {
	// contains filtered or unexported fields
}

func (CreateBigkeyScanTaskResponseScanType) MarshalJSON 

func (c CreateBigkeyScanTaskResponseScanType) MarshalJSON() ([]byte, error)

func (*CreateBigkeyScanTaskResponseScanType) UnmarshalJSON 

func (c *CreateBigkeyScanTaskResponseScanType) UnmarshalJSON(b []byte) error

func (CreateBigkeyScanTaskResponseScanType) Value 

func (c CreateBigkeyScanTaskResponseScanType) Value() string

type CreateBigkeyScanTaskResponseScanTypeEnum 

type CreateBigkeyScanTaskResponseScanTypeEnum struct {
	MANUAL CreateBigkeyScanTaskResponseScanType
	AUTO   CreateBigkeyScanTaskResponseScanType
}

func GetCreateBigkeyScanTaskResponseScanTypeEnum 

func GetCreateBigkeyScanTaskResponseScanTypeEnum() CreateBigkeyScanTaskResponseScanTypeEnum

type CreateBigkeyScanTaskResponseStatus 

type CreateBigkeyScanTaskResponseStatus struct {
	// contains filtered or unexported fields
}

func (CreateBigkeyScanTaskResponseStatus) MarshalJSON 

func (c CreateBigkeyScanTaskResponseStatus) MarshalJSON() ([]byte, error)

func (*CreateBigkeyScanTaskResponseStatus) UnmarshalJSON 

func (c *CreateBigkeyScanTaskResponseStatus) UnmarshalJSON(b []byte) error

func (CreateBigkeyScanTaskResponseStatus) Value 

func (c CreateBigkeyScanTaskResponseStatus) Value() string

type CreateBigkeyScanTaskResponseStatusEnum 

type CreateBigkeyScanTaskResponseStatusEnum struct {
	WAITING CreateBigkeyScanTaskResponseStatus
	RUNNING CreateBigkeyScanTaskResponseStatus
	SUCCESS CreateBigkeyScanTaskResponseStatus
	FAILED  CreateBigkeyScanTaskResponseStatus
}

func GetCreateBigkeyScanTaskResponseStatusEnum 

func GetCreateBigkeyScanTaskResponseStatusEnum() CreateBigkeyScanTaskResponseStatusEnum

type CreateCustomTemplateBody 

type CreateCustomTemplateBody struct {

	// 来源系统模板ID
	TemplateId *string `json:"template_id,omitempty"`

	// 模板名称
	Name string `json:"name"`

	// 模板类型
	Type *string `json:"type,omitempty"`

	// 缓存引擎：Redis[和Memcached](tag:hws,hws_hk,ocb,sbc,tm,ctc,cmcc)。
	Engine *string `json:"engine,omitempty"`

	// 缓存实例类型。取值范围如下： - single：表示单机实例 - ha：表示主备实例 - cluster：表示cluster集群实例 - proxy：表示Proxy集群实例 [- ha_rw_split： 表示读写分离实例](tag:hws)
	CacheMode *string `json:"cache_mode,omitempty"`

	// 模板的描述信息
	Description *string `json:"description,omitempty"`

	// 缓存版本。  当缓存引擎为Redis时，取值为4.0或5.0。  [当缓存引擎为Memcached时，该字段为可选，取值为空。](tag:hws,hws_hk,ocb,sbc,tm,ctc,cmcc)
	EngineVersion *string `json:"engine_version,omitempty"`

	// 参数配置信息
	Params map[string]string `json:"params,omitempty"`
}

func (CreateCustomTemplateBody) String 

func (o CreateCustomTemplateBody) String() string

type CreateCustomTemplateRequest 

type CreateCustomTemplateRequest struct {
	Body *CreateCustomTemplateBody `json:"body,omitempty"`
}

CreateCustomTemplateRequest Request Object

func (CreateCustomTemplateRequest) String 

func (o CreateCustomTemplateRequest) String() string

type CreateCustomTemplateResponse 

type CreateCustomTemplateResponse struct {

	// 模板ID
	Id             *string `json:"id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CreateCustomTemplateResponse Response Object

func (CreateCustomTemplateResponse) String 

func (o CreateCustomTemplateResponse) String() string

type CreateDiagnosisTaskBody 

type CreateDiagnosisTaskBody struct {

	// 诊断开始时间。UNIX时间戳，单位毫秒。
	BeginTime string `json:"begin_time"`

	// 诊断结束时间。UNIX时间戳，单位毫秒。
	EndTime string `json:"end_time"`

	// 诊断节点IP列表。默认诊断所有节点。 非读写分离实例查询方法如下：   - 方法一：参考[查看实例信息](https://support.huaweicloud.com/usermanual-dcs/dcs-ug-0312016.html)。   - 方法二：调用[查询指定实例](https://support.huaweicloud.com/api-dcs/ShowInstance.html)查询。  读写分离实例查询方法：调用[查询分片信息](https://support.huaweicloud.com/api-dcs/ListGroupReplicationInfo.html#ListGroupReplicationInfo__response_InstanceReplicationListInfo)。
	NodeIpList *[]string `json:"node_ip_list,omitempty"`
}

CreateDiagnosisTaskBody 发起实例诊断请求体

func (CreateDiagnosisTaskBody) String 

func (o CreateDiagnosisTaskBody) String() string

type CreateDiagnosisTaskRequest 

type CreateDiagnosisTaskRequest struct {

	// 实例ID
	InstanceId string `json:"instance_id"`

	Body *CreateDiagnosisTaskBody `json:"body,omitempty"`
}

CreateDiagnosisTaskRequest Request Object

func (CreateDiagnosisTaskRequest) String 

func (o CreateDiagnosisTaskRequest) String() string

type CreateDiagnosisTaskResponse 

type CreateDiagnosisTaskResponse struct {

	// 报告ID
	ReportId       *string `json:"report_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CreateDiagnosisTaskResponse Response Object

func (CreateDiagnosisTaskResponse) String 

func (o CreateDiagnosisTaskResponse) String() string

type CreateHotkeyScanTaskRequest 

type CreateHotkeyScanTaskRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

CreateHotkeyScanTaskRequest Request Object

func (CreateHotkeyScanTaskRequest) String 

func (o CreateHotkeyScanTaskRequest) String() string

type CreateHotkeyScanTaskResponse 

type CreateHotkeyScanTaskResponse struct {

	// 热key分析记录ID
	Id *string `json:"id,omitempty"`

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 分析任务状态
	Status *CreateHotkeyScanTaskResponseStatus `json:"status,omitempty"`

	// 分析方式
	ScanType *CreateHotkeyScanTaskResponseScanType `json:"scan_type,omitempty"`

	// 分析任务创建时间,格式为：\"2020-06-15T02:21:18.669Z\"
	CreatedAt *string `json:"created_at,omitempty"`

	// 分析任务开始时间,格式为：\"2020-06-15T02:21:18.669Z\"
	StartedAt *string `json:"started_at,omitempty"`

	// 分析任务结束时间,格式为：\"2020-06-15T02:21:18.669Z\"
	FinishedAt *string `json:"finished_at,omitempty"`

	// 热key的数量
	Num *int32 `json:"num,omitempty"`

	// 热key记录
	Keys           *[]HotkeysBody `json:"keys,omitempty"`
	HttpStatusCode int            `json:"-"`
}

CreateHotkeyScanTaskResponse Response Object

func (CreateHotkeyScanTaskResponse) String 

func (o CreateHotkeyScanTaskResponse) String() string

type CreateHotkeyScanTaskResponseScanType 

type CreateHotkeyScanTaskResponseScanType struct {
	// contains filtered or unexported fields
}

func (CreateHotkeyScanTaskResponseScanType) MarshalJSON 

func (c CreateHotkeyScanTaskResponseScanType) MarshalJSON() ([]byte, error)

func (*CreateHotkeyScanTaskResponseScanType) UnmarshalJSON 

func (c *CreateHotkeyScanTaskResponseScanType) UnmarshalJSON(b []byte) error

func (CreateHotkeyScanTaskResponseScanType) Value 

func (c CreateHotkeyScanTaskResponseScanType) Value() string

type CreateHotkeyScanTaskResponseScanTypeEnum 

type CreateHotkeyScanTaskResponseScanTypeEnum struct {
	MANUAL CreateHotkeyScanTaskResponseScanType
	AUTO   CreateHotkeyScanTaskResponseScanType
}

func GetCreateHotkeyScanTaskResponseScanTypeEnum 

func GetCreateHotkeyScanTaskResponseScanTypeEnum() CreateHotkeyScanTaskResponseScanTypeEnum

type CreateHotkeyScanTaskResponseStatus 

type CreateHotkeyScanTaskResponseStatus struct {
	// contains filtered or unexported fields
}

func (CreateHotkeyScanTaskResponseStatus) MarshalJSON 

func (c CreateHotkeyScanTaskResponseStatus) MarshalJSON() ([]byte, error)

func (*CreateHotkeyScanTaskResponseStatus) UnmarshalJSON 

func (c *CreateHotkeyScanTaskResponseStatus) UnmarshalJSON(b []byte) error

func (CreateHotkeyScanTaskResponseStatus) Value 

func (c CreateHotkeyScanTaskResponseStatus) Value() string

type CreateHotkeyScanTaskResponseStatusEnum 

type CreateHotkeyScanTaskResponseStatusEnum struct {
	WAITING CreateHotkeyScanTaskResponseStatus
	RUNNING CreateHotkeyScanTaskResponseStatus
	SUCCESS CreateHotkeyScanTaskResponseStatus
	FAILED  CreateHotkeyScanTaskResponseStatus
}

func GetCreateHotkeyScanTaskResponseStatusEnum 

func GetCreateHotkeyScanTaskResponseStatusEnum() CreateHotkeyScanTaskResponseStatusEnum

type CreateInstanceBody 

type CreateInstanceBody struct {

	// 实例名称。  由英文字符开头，只能由英文字母、数字、中划线和下划线组成。  创建单个实例时，名称长度为4到64位的字符串。批量创建实例时，名称长度为4到56位的字符串，且实例名称格式为“自定义名称-n”，其中n从000开始，依次递增。例如，批量创建两个实例，自定义名称为dcs_demo，则两个实例的名称为dcs_demo-000和dcs_demo-001。
	Name string `json:"name"`

	// 缓存引擎：Redis和Memcached。
	Engine string `json:"engine"`

	// 缓存版本。  当缓存引擎为Redis时，取值为3.0、4.0或5.0。  当缓存引擎为Memcached时，该字段为可选，取值为空。
	EngineVersion *string `json:"engine_version,omitempty"`

	// 缓存容量（G Byte） - Redis3.0：单机和主备类型实例取值：2、4、8、16、32、64。Proxy集群实例规格支持64、128、256、512和1024。 - Redis4.0和Redis5.0：单机和主备类型实例取值：0.125、0.25、0.5、1、2、4、8、16、32、64。Cluster集群实例规格支持24、32、48、64、96、128、192、256、384、512、768、1024。 - Memcached：单机和主备类型实例取值：2、4、8、16、32、64。
	Capacity float32 `json:"capacity"`

	// 产品规格编码。具体查询方法如下：  - 方法一：查询产品介绍中的[实例规格](https://support.huaweicloud.com/productdesc-dcs/dcs-pd-0522002.html) - 方法二：登录分布式缓存的控制台界面，点击购买缓存实例，查找对应的实例规格名称 - 方法三：调用[查询产品规格](https://support.huaweicloud.com/api-dcs/ListFlavors.html)接口查询。
	SpecCode string `json:"spec_code"`

	// 创建缓存节点到指定且有资源的可用区Code。创建缓存节点到指定且有资源的可用区Code。具体查询方法，请参考[查询可用区信息](https://support.huaweicloud.com/api-dcs/ListAvailableZones.html)，在查询时，请注意查看该可用区是否有资源。  如果是创建主备、Proxy集群、Cluster集群实例，支持跨可用区部署，可以为备节点指定备可用区。在为节点指定可用区时，用逗号分隔开，具体请查看示例。
	AzCodes []string `json:"az_codes"`

	// 虚拟私有云ID。  获取方法如下：   - 方法1：登录虚拟私有云服务的控制台界面，在虚拟私有云的详情页面查找VPC ID。   - 方法2：通过虚拟私有云服务的API接口查询，具体操作可参考[查询VPC列表](https://support.huaweicloud.com/api-vpc/vpc_api01_0003.html)。
	VpcId string `json:"vpc_id"`

	// 子网的网络ID。  获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，单击VPC下的子网，进入子网详情页面，查找网络ID。 - 方法2：通过虚拟私有云服务的API接口查询，具体操作可参考[查询子网列表](https://support.huaweicloud.com/api-vpc/vpc_subnet01_0003.html)。
	SubnetId string `json:"subnet_id"`

	// 指定实例所属的安全组。  当engine为Redis且engine_version为3.0时，或engine为Memcached时，该参数为必选。Redis3.0和Memcached实例支持安全组访问控制。  当engine为Redis且engine_version为4.0和5.0时，该参数为可选。Redis4.0和Redis5.0版本实例不支持安全组控制访问，只支持白名单控制。  获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，在安全组的详情页面查找安全组ID。 - 方法2：通过虚拟私有云服务的API接口查询，具体操作可参考[查询安全组列表](https://support.huaweicloud.com/api-vpc/vpc_sg01_0002.html)。
	SecurityGroupId *string `json:"security_group_id,omitempty"`

	// Redis缓存实例绑定的弹性IP地址的id。  如果开启了公网访问功能（即enable_publicip为true），该字段为必选。
	PublicipId *string `json:"publicip_id,omitempty"`

	// 企业项目ID。
	EnterpriseProjectId *string `json:"enterprise_project_id,omitempty"`

	// 企业项目名称。
	EnterpriseProjectName *string `json:"enterprise_project_name,omitempty"`

	// 实例的描述信息。  长度不超过1024的字符串。 > \\与\"在json报文中属于特殊字符，如果参数值中需要显示\\或者\"字符，请在字符前增加转义字符\\，比如\\\\或者\\\"。
	Description *string `json:"description,omitempty"`

	// Redis缓存实例开启公网访问功能时，是否选择支持ssl。 - true：开启 - false：不开启
	EnableSsl *bool `json:"enable_ssl,omitempty"`

	// 创建缓存实例手动指定的IP地址,支持Redis和Memcached。
	PrivateIp *string `json:"private_ip,omitempty"`

	// 表示批量创建缓存实例时，购买的实例个数。仅Redis和Memcached实例支持批量创建。  默认值：1  取值范围：1-100
	InstanceNum *int32 `json:"instance_num,omitempty"`

	// 维护时间窗开始时间，为UTC时间，格式为HH:mm:ss - 维护时间窗开始和结束时间必须为指定的时间段，可参考[查询维护时间窗时间段](https://support.huaweicloud.com/api-dcs/ListMaintenanceWindows.html)获取。 - 开始时间必须为22:00:00、02:00:00、06:00:00、10:00:00、14:00:00和18:00:00。 - 该参数不能单独为空，若该值为空，则结束时间也为空。系统分配一个默认开始时间02:00:00。
	MaintainBegin *string `json:"maintain_begin,omitempty"`

	// 维护时间窗结束时间，为UTC时间，格式为HH:mm:ss。 - 维护时间窗开始和结束时间必须为指定的时间段，可参考[查询维护时间窗时间段](https://support.huaweicloud.com/api-dcs/ListMaintenanceWindows.html)获取。 - 结束时间在开始时间基础上加四个小时，即当开始时间为22:00:00时，结束时间为02:00:00。 - 该参数不能单独为空，若该值为空，则开始时间也为空，系统分配一个默认结束时间06:00:00。
	MaintainEnd *string `json:"maintain_end,omitempty"`

	// 缓存实例的认证信息 > 当“no_password_access”配置为“false”或未配置时，请求消息中须包含password参数。 Redis类型的缓存实例密码复杂度要求： - 输入长度为8到32位的字符串。 - 新密码不能与旧密码相同。 - 必须包含如下四种字符中的三种组合：   - 小写字母   - 大写字母   - 数字   - 特殊字符包括（`~!@#$^&*()-_=+\\|{}:'\",<.>/?）
	Password *string `json:"password,omitempty"`

	// 是否允许免密码访问缓存实例。 - true：该实例无需密码即可访问。 - false：该实例必须通过密码认证才能访问。 若未配置该参数则默认值为“false”。
	NoPasswordAccess *bool `json:"no_password_access,omitempty"`

	BssParam *BssParam `json:"bss_param,omitempty"`

	InstanceBackupPolicy *BackupPolicy `json:"instance_backup_policy,omitempty"`

	// 实例标签键值。
	Tags *[]ResourceTag `json:"tags,omitempty"`

	// 当缓存类型为Redis时，则不需要设置，保持为空即可。  当缓存引擎为Memcached，且“no_password_access”为“false”时才需要设置，表示通过密码认证访问缓存实例的认证用户名。  由英文字符开头，只能由英文字母、数字、中划线和下划线组成，长度为1~64的字符。 >   - 当缓存引擎为Memcached时，该参数为可选项。   - 当缓存引擎为Redis时，该参数不需要设置。
	AccessUser *string `json:"access_user,omitempty"`

	// Redis缓存实例是否开启公网访问功能。 - true：开启 - false：不开启
	EnablePublicip *bool `json:"enable_publicip,omitempty"`

	// 实例自定义端口。只有创建Redis4.0和Redis5.0实例才支持自定义端口，Redis3.0和Memcached实例不支持。  创建Redis4.0和Redis5.0实例，如果没发送该参数或该参数为空，表示实例使用默认端口6379。如果自定义端口，端口范围为1~65535的任意数字。
	Port *int32 `json:"port,omitempty"`

	// 支持自定义重命名高危命令。只有创建Redis4.0和Redis5.0实例才支持重命名高危命令，Redis3.0和Memcached实例不支持。  创建Redis4.0和Redis5.0实例，如果没发送该参数或该参数为空，表示没有需要重命名的命令。当前支持重命名的高危命令有command、keys、flushdb、flushall和hgetall，其他命令暂不支持重命名。
	RenameCommands *interface{} `json:"rename_commands,omitempty"`

	// 参数模板ID
	TemplateId *string `json:"template_id,omitempty"`
}

func (CreateInstanceBody) String 

func (o CreateInstanceBody) String() string

type CreateInstanceRequest 

type CreateInstanceRequest struct {
	Body *CreateInstanceBody `json:"body,omitempty"`
}

CreateInstanceRequest Request Object

func (CreateInstanceRequest) String 

func (o CreateInstanceRequest) String() string

type CreateInstanceResponse 

type CreateInstanceResponse struct {

	// 订单ID，仅在创建包周期实例时返回。
	OrderId *string `json:"order_id,omitempty"`

	// 缓存实例ID和名称，如果批量创建实例，则会返回多个。
	Instances      *[]Instances `json:"instances,omitempty"`
	HttpStatusCode int          `json:"-"`
}

CreateInstanceResponse Response Object

func (CreateInstanceResponse) String 

func (o CreateInstanceResponse) String() string

type CreateMigrationTaskBody 

type CreateMigrationTaskBody struct {

	// 迁移任务名称。
	TaskName string `json:"task_name"`

	// 迁移任务描述。
	Description *string `json:"description,omitempty"`

	// 迁移任务类型,包括备份文件导入和在线迁移两种类型。 取值范围： - backupfile_import：表示备份文件导入 - online_migration：表示在线迁移。
	MigrationType CreateMigrationTaskBodyMigrationType `json:"migration_type"`

	// 迁移方式，包括全量迁移和增量迁移两种类型。 取值范围： - full_amount_migration：表示全量迁移。 - incremental_migration：表示增量迁移。
	MigrationMethod CreateMigrationTaskBodyMigrationMethod `json:"migration_method"`

	BackupFiles *BackupFilesBody `json:"backup_files,omitempty"`

	// 迁移任务类型为在线迁移时，表示源Redis和目标Redis联通的网络类型，包括vpc和vpn两种类型。
	NetworkType *CreateMigrationTaskBodyNetworkType `json:"network_type,omitempty"`

	SourceInstance *SourceInstanceBody `json:"source_instance,omitempty"`

	TargetInstance *TargetInstanceBody `json:"target_instance"`
}

CreateMigrationTaskBody 创建数据迁移任务结构体

func (CreateMigrationTaskBody) String 

func (o CreateMigrationTaskBody) String() string

type CreateMigrationTaskBodyMigrationMethod 

type CreateMigrationTaskBodyMigrationMethod struct {
	// contains filtered or unexported fields
}

func (CreateMigrationTaskBodyMigrationMethod) MarshalJSON 

func (c CreateMigrationTaskBodyMigrationMethod) MarshalJSON() ([]byte, error)

func (*CreateMigrationTaskBodyMigrationMethod) UnmarshalJSON 

func (c *CreateMigrationTaskBodyMigrationMethod) UnmarshalJSON(b []byte) error

func (CreateMigrationTaskBodyMigrationMethod) Value 

func (c CreateMigrationTaskBodyMigrationMethod) Value() string

type CreateMigrationTaskBodyMigrationMethodEnum 

type CreateMigrationTaskBodyMigrationMethodEnum struct {
	FULL_AMOUNT_MIGRATION CreateMigrationTaskBodyMigrationMethod
	INCREMENTAL_MIGRATION CreateMigrationTaskBodyMigrationMethod
}

func GetCreateMigrationTaskBodyMigrationMethodEnum 

func GetCreateMigrationTaskBodyMigrationMethodEnum() CreateMigrationTaskBodyMigrationMethodEnum

type CreateMigrationTaskBodyMigrationType 

type CreateMigrationTaskBodyMigrationType struct {
	// contains filtered or unexported fields
}

func (CreateMigrationTaskBodyMigrationType) MarshalJSON 

func (c CreateMigrationTaskBodyMigrationType) MarshalJSON() ([]byte, error)

func (*CreateMigrationTaskBodyMigrationType) UnmarshalJSON 

func (c *CreateMigrationTaskBodyMigrationType) UnmarshalJSON(b []byte) error

func (CreateMigrationTaskBodyMigrationType) Value 

func (c CreateMigrationTaskBodyMigrationType) Value() string

type CreateMigrationTaskBodyMigrationTypeEnum 

type CreateMigrationTaskBodyMigrationTypeEnum struct {
	BACKUPFILE_IMPORT CreateMigrationTaskBodyMigrationType
	ONLINE_MIGRATION  CreateMigrationTaskBodyMigrationType
}

func GetCreateMigrationTaskBodyMigrationTypeEnum 

func GetCreateMigrationTaskBodyMigrationTypeEnum() CreateMigrationTaskBodyMigrationTypeEnum

type CreateMigrationTaskBodyNetworkType 

type CreateMigrationTaskBodyNetworkType struct {
	// contains filtered or unexported fields
}

func (CreateMigrationTaskBodyNetworkType) MarshalJSON 

func (c CreateMigrationTaskBodyNetworkType) MarshalJSON() ([]byte, error)

func (*CreateMigrationTaskBodyNetworkType) UnmarshalJSON 

func (c *CreateMigrationTaskBodyNetworkType) UnmarshalJSON(b []byte) error

func (CreateMigrationTaskBodyNetworkType) Value 

func (c CreateMigrationTaskBodyNetworkType) Value() string

type CreateMigrationTaskBodyNetworkTypeEnum 

type CreateMigrationTaskBodyNetworkTypeEnum struct {
	VPC CreateMigrationTaskBodyNetworkType
	VPN CreateMigrationTaskBodyNetworkType
}

func GetCreateMigrationTaskBodyNetworkTypeEnum 

func GetCreateMigrationTaskBodyNetworkTypeEnum() CreateMigrationTaskBodyNetworkTypeEnum

type CreateMigrationTaskRequest 

type CreateMigrationTaskRequest struct {
	Body *CreateMigrationTaskBody `json:"body,omitempty"`
}

CreateMigrationTaskRequest Request Object

func (CreateMigrationTaskRequest) String 

func (o CreateMigrationTaskRequest) String() string

type CreateMigrationTaskResponse 

type CreateMigrationTaskResponse struct {

	// 迁移任务ID。
	Id *string `json:"id,omitempty"`

	// 迁移任务名称。
	Name *string `json:"name,omitempty"`

	// 迁移任务状态，这个字段的值包括：SUCCESS, FAILED, MIGRATING，TERMINATED
	Status         *CreateMigrationTaskResponseStatus `json:"status,omitempty"`
	HttpStatusCode int                                `json:"-"`
}

CreateMigrationTaskResponse Response Object

func (CreateMigrationTaskResponse) String 

func (o CreateMigrationTaskResponse) String() string

type CreateMigrationTaskResponseStatus 

type CreateMigrationTaskResponseStatus struct {
	// contains filtered or unexported fields
}

func (CreateMigrationTaskResponseStatus) MarshalJSON 

func (c CreateMigrationTaskResponseStatus) MarshalJSON() ([]byte, error)

func (*CreateMigrationTaskResponseStatus) UnmarshalJSON 

func (c *CreateMigrationTaskResponseStatus) UnmarshalJSON(b []byte) error

func (CreateMigrationTaskResponseStatus) Value 

func (c CreateMigrationTaskResponseStatus) Value() string

type CreateMigrationTaskResponseStatusEnum 

type CreateMigrationTaskResponseStatusEnum struct {
	SUCCESS    CreateMigrationTaskResponseStatus
	FAILED     CreateMigrationTaskResponseStatus
	MIGRATING  CreateMigrationTaskResponseStatus
	TERMINATED CreateMigrationTaskResponseStatus
}

func GetCreateMigrationTaskResponseStatusEnum 

func GetCreateMigrationTaskResponseStatusEnum() CreateMigrationTaskResponseStatusEnum

type CreateOnlineMigrationTaskBody 

type CreateOnlineMigrationTaskBody struct {

	// 在线迁移任务名称。
	Name string `json:"name"`

	// 在线迁移任务描述。
	Description *string `json:"description,omitempty"`

	// 虚拟私有云ID。   获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，在虚拟私有云的详情页面查找VPC ID。  - 方法2：通过虚拟私有云服务的API接口查询，具体操作可参考[查询VPC列表](https://support.huaweicloud.com/api-vpc/vpc_apiv3_0003.html)。
	VpcId string `json:"vpc_id"`

	// 子网的网络ID。  获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，单击VPC下的子网，进入子网详情页面，查找网络ID。  - 方法2：通过虚拟私有云服务的API接口查询，具体操作可参考[查询子网列表](https://support.huaweicloud.com/api-vpc/vpc_subnet01_0003.html)。
	SubnetId string `json:"subnet_id"`

	// 指定实例所属的安全组。 安全组用来实现安全组内和组间虚拟机的访问控制，加强虚拟机的安全保护。您可以在安全组中定义各种访问规则，当虚拟机加入该安全组后，即受到这些访问规则的保护。   获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，访问控制安全组选项下可以对安全组进行创建和配置,并获取安全组ID。  - 方法2：通过虚拟私有云服务的API接口查询，具体操作可参考[查询安全组列表](https://support.huaweicloud.com/api-vpc/vpc_apiv3_0012.html)。
	SecurityGroupId string `json:"security_group_id"`
}

CreateOnlineMigrationTaskBody 创建在线数据迁移任务结构体

func (CreateOnlineMigrationTaskBody) String 

func (o CreateOnlineMigrationTaskBody) String() string

type CreateOnlineMigrationTaskRequest 

type CreateOnlineMigrationTaskRequest struct {
	Body *CreateOnlineMigrationTaskBody `json:"body,omitempty"`
}

CreateOnlineMigrationTaskRequest Request Object

func (CreateOnlineMigrationTaskRequest) String 

func (o CreateOnlineMigrationTaskRequest) String() string

type CreateOnlineMigrationTaskResponse 

type CreateOnlineMigrationTaskResponse struct {

	// 在线迁移任务ID。
	InstanceId     *string `json:"instance_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CreateOnlineMigrationTaskResponse Response Object

func (CreateOnlineMigrationTaskResponse) String 

func (o CreateOnlineMigrationTaskResponse) String() string

type CreateOrDeleteInstanceTags 

type CreateOrDeleteInstanceTags struct {

	// 操作标识：仅限于create（创建）、delete（删除）。
	Action string `json:"action"`

	// 标签列表。
	Tags *[]ResourceTag `json:"tags,omitempty"`
}

func (CreateOrDeleteInstanceTags) String 

func (o CreateOrDeleteInstanceTags) String() string

type CreateRedislogDownloadLinkRequest 

type CreateRedislogDownloadLinkRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 日志的唯一ID，来自于查询运行日志查询接口
	Id string `json:"id"`
}

CreateRedislogDownloadLinkRequest Request Object

func (CreateRedislogDownloadLinkRequest) String 

func (o CreateRedislogDownloadLinkRequest) String() string

type CreateRedislogDownloadLinkResponse 

type CreateRedislogDownloadLinkResponse struct {

	// 日志id
	Id *string `json:"id,omitempty"`

	// 后台任务id
	BackupId *string `json:"backup_id,omitempty"`

	// 日志下载链接，默认有效时间为24小时
	Link           *string `json:"link,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CreateRedislogDownloadLinkResponse Response Object

func (CreateRedislogDownloadLinkResponse) String 

func (o CreateRedislogDownloadLinkResponse) String() string

type CreateRedislogRequest 

type CreateRedislogRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 日期偏移量，表示从过去的n天开始查询，例如：传入0则表示查询今天的日志，传入7则表示查询过去7天的日志。最大支持0-7。
	QueryTime *int32 `json:"query_time,omitempty"`

	// 返回日志的类型，当前仅支持Redis运行日志，类型为run
	LogType string `json:"log_type"`

	// 副本ID，可以从分片与副本中查询对应节点的副本ID
	ReplicationId *string `json:"replication_id,omitempty"`
}

CreateRedislogRequest Request Object

func (CreateRedislogRequest) String 

func (o CreateRedislogRequest) String() string

type CreateRedislogResponse 

type CreateRedislogResponse struct {
	HttpStatusCode int `json:"-"`
}

CreateRedislogResponse Response Object

func (CreateRedislogResponse) String 

func (o CreateRedislogResponse) String() string

type DeleteBackgroundTaskRequest 

type DeleteBackgroundTaskRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 后台任务ID
	TaskId string `json:"task_id"`
}

DeleteBackgroundTaskRequest Request Object

func (DeleteBackgroundTaskRequest) String 

func (o DeleteBackgroundTaskRequest) String() string

type DeleteBackgroundTaskResponse 

type DeleteBackgroundTaskResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteBackgroundTaskResponse Response Object

func (DeleteBackgroundTaskResponse) String 

func (o DeleteBackgroundTaskResponse) String() string

type DeleteBackupFileRequest 

type DeleteBackupFileRequest struct {

	// 备份记录ID。
	BackupId string `json:"backup_id"`

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

DeleteBackupFileRequest Request Object

func (DeleteBackupFileRequest) String 

func (o DeleteBackupFileRequest) String() string

type DeleteBackupFileResponse 

type DeleteBackupFileResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteBackupFileResponse Response Object

func (DeleteBackupFileResponse) String 

func (o DeleteBackupFileResponse) String() string

type DeleteBigkeyScanTaskRequest 

type DeleteBigkeyScanTaskRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 大key分析任务ID。
	BigkeyId string `json:"bigkey_id"`
}

DeleteBigkeyScanTaskRequest Request Object

func (DeleteBigkeyScanTaskRequest) String 

func (o DeleteBigkeyScanTaskRequest) String() string

type DeleteBigkeyScanTaskResponse 

type DeleteBigkeyScanTaskResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteBigkeyScanTaskResponse Response Object

func (DeleteBigkeyScanTaskResponse) String 

func (o DeleteBigkeyScanTaskResponse) String() string

type DeleteHotkeyScanTaskRequest 

type DeleteHotkeyScanTaskRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 热key分析任务ID。
	HotkeyId string `json:"hotkey_id"`
}

DeleteHotkeyScanTaskRequest Request Object

func (DeleteHotkeyScanTaskRequest) String 

func (o DeleteHotkeyScanTaskRequest) String() string

type DeleteHotkeyScanTaskResponse 

type DeleteHotkeyScanTaskResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteHotkeyScanTaskResponse Response Object

func (DeleteHotkeyScanTaskResponse) String 

func (o DeleteHotkeyScanTaskResponse) String() string

type DeleteIpFromDomainNameRequest 

type DeleteIpFromDomainNameRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 分片ID。
	GroupId string `json:"group_id"`

	// 节点ID。
	NodeId string `json:"node_id"`
}

DeleteIpFromDomainNameRequest Request Object

func (DeleteIpFromDomainNameRequest) String 

func (o DeleteIpFromDomainNameRequest) String() string

type DeleteIpFromDomainNameResponse 

type DeleteIpFromDomainNameResponse struct {

	// 域名摘除ip的任务ID。
	JobId          *string `json:"job_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

DeleteIpFromDomainNameResponse Response Object

func (DeleteIpFromDomainNameResponse) String 

func (o DeleteIpFromDomainNameResponse) String() string

type DeleteMigrateTaskRequest 

type DeleteMigrateTaskRequest struct {

	// 删除的迁移任务ID列表。
	TaskIdList []string `json:"task_id_list"`
}

DeleteMigrateTaskRequest 删除迁移任务请求体

func (DeleteMigrateTaskRequest) String 

func (o DeleteMigrateTaskRequest) String() string

type DeleteMigrationTaskRequest 

type DeleteMigrationTaskRequest struct {
	Body *DeleteMigrateTaskRequest `json:"body,omitempty"`
}

DeleteMigrationTaskRequest Request Object

func (DeleteMigrationTaskRequest) String 

func (o DeleteMigrationTaskRequest) String() string

type DeleteMigrationTaskResponse 

type DeleteMigrationTaskResponse struct {

	// 删除的迁移任务ID列表。
	TaskIdList     *[]string `json:"task_id_list,omitempty"`
	HttpStatusCode int       `json:"-"`
}

DeleteMigrationTaskResponse Response Object

func (DeleteMigrationTaskResponse) String 

func (o DeleteMigrationTaskResponse) String() string

type DeleteSingleInstanceRequest 

type DeleteSingleInstanceRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

DeleteSingleInstanceRequest Request Object

func (DeleteSingleInstanceRequest) String 

func (o DeleteSingleInstanceRequest) String() string

type DeleteSingleInstanceResponse 

type DeleteSingleInstanceResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteSingleInstanceResponse Response Object

func (DeleteSingleInstanceResponse) String 

func (o DeleteSingleInstanceResponse) String() string

type DetailsBody 

type DetailsBody struct {

	// 变更前的容量，仅在变更规格时有值
	OldCapacity *string `json:"old_capacity,omitempty"`

	// 变更后的容量，仅在变更规格时有值
	NewCapacity *string `json:"new_capacity,omitempty"`

	// 是否开启公网访问，仅在开启公网访问时有值
	EnablePublicIp *bool `json:"enable_public_ip,omitempty"`

	// 公网IP的ID，仅在开启公网访问时有值
	PublicIpId *string `json:"public_ip_id,omitempty"`

	// 公网IP地址，仅在开启公网访问时有值
	PublicIpAddress *string `json:"public_ip_address,omitempty"`

	// 是否开启ssl，仅在开启ssl时有值
	EnableSsl *bool `json:"enable_ssl,omitempty"`

	// 变更前的缓存类型，仅在变更规格时有值
	OldCacheMode *string `json:"old_cache_mode,omitempty"`

	// 变更后的缓存类型，仅在变更规格时有值
	NewCacheMode *string `json:"new_cache_mode,omitempty"`
}

DetailsBody 详细信息结构体

func (DetailsBody) String 

func (o DetailsBody) String() string

type DiagnosisDimension 

type DiagnosisDimension struct {

	// 诊断维度名称
	Name DiagnosisDimensionName `json:"name"`

	// 诊断结果为异常的诊断项总数
	AbnormalNum int32 `json:"abnormal_num"`

	// 诊断失败的诊断项总数
	FailedNum int32 `json:"failed_num"`

	// 诊断项列表
	DiagnosisItemList []DiagnosisItem `json:"diagnosis_item_list"`
}

DiagnosisDimension 诊断维度

func (DiagnosisDimension) String 

func (o DiagnosisDimension) String() string

type DiagnosisDimensionName 

type DiagnosisDimensionName struct {
	// contains filtered or unexported fields
}

func (DiagnosisDimensionName) MarshalJSON 

func (c DiagnosisDimensionName) MarshalJSON() ([]byte, error)

func (*DiagnosisDimensionName) UnmarshalJSON 

func (c *DiagnosisDimensionName) UnmarshalJSON(b []byte) error

func (DiagnosisDimensionName) Value 

func (c DiagnosisDimensionName) Value() string

type DiagnosisDimensionNameEnum 

type DiagnosisDimensionNameEnum struct {
	NETWORK DiagnosisDimensionName
	STORAGE DiagnosisDimensionName
	LOAD    DiagnosisDimensionName
}

func GetDiagnosisDimensionNameEnum 

func GetDiagnosisDimensionNameEnum() DiagnosisDimensionNameEnum

type DiagnosisItem 

type DiagnosisItem struct {

	// 诊断项名称
	Name DiagnosisItemName `json:"name"`

	// 原因ID列表
	CauseIds *[]ConclusionItem `json:"cause_ids,omitempty"`

	// 影响ID列表
	ImpactIds *[]ConclusionItem `json:"impact_ids,omitempty"`

	// 建议ID列表
	AdviceIds *[]ConclusionItem `json:"advice_ids,omitempty"`

	// 诊断结果
	Result DiagnosisItemResult `json:"result"`
}

DiagnosisItem 诊断项

func (DiagnosisItem) String 

func (o DiagnosisItem) String() string

type DiagnosisItemName 

type DiagnosisItemName struct {
	// contains filtered or unexported fields
}

func (DiagnosisItemName) MarshalJSON 

func (c DiagnosisItemName) MarshalJSON() ([]byte, error)

func (*DiagnosisItemName) UnmarshalJSON 

func (c *DiagnosisItemName) UnmarshalJSON(b []byte) error

func (DiagnosisItemName) Value 

func (c DiagnosisItemName) Value() string

type DiagnosisItemNameEnum 

type DiagnosisItemNameEnum struct {
	CONNECTION_NUM             DiagnosisItemName
	RX_CONTROLLED              DiagnosisItemName
	PERSISTENCE                DiagnosisItemName
	CENTRALIZED_EXPIRATION     DiagnosisItemName
	INNER_MEMORY_FRAGMENTATION DiagnosisItemName
	TIME_CONSUMING_COMMANDS    DiagnosisItemName
	HIT_RATIO                  DiagnosisItemName
	MEMORY_USAGE               DiagnosisItemName
	CPU_USAGE                  DiagnosisItemName
}

func GetDiagnosisItemNameEnum 

func GetDiagnosisItemNameEnum() DiagnosisItemNameEnum

type DiagnosisItemResult 

type DiagnosisItemResult struct {
	// contains filtered or unexported fields
}

func (DiagnosisItemResult) MarshalJSON 

func (c DiagnosisItemResult) MarshalJSON() ([]byte, error)

func (*DiagnosisItemResult) UnmarshalJSON 

func (c *DiagnosisItemResult) UnmarshalJSON(b []byte) error

func (DiagnosisItemResult) Value 

func (c DiagnosisItemResult) Value() string

type DiagnosisItemResultEnum 

type DiagnosisItemResultEnum struct {
	FAILED   DiagnosisItemResult
	ABNORMAL DiagnosisItemResult
	NORMAL   DiagnosisItemResult
}

func GetDiagnosisItemResultEnum 

func GetDiagnosisItemResultEnum() DiagnosisItemResultEnum

type DiagnosisNodeReport 

type DiagnosisNodeReport struct {

	// 节点IP。例如：192.168.0.234:6379
	NodeIp string `json:"node_ip"`

	// 节点所在可用区Code
	AzCode string `json:"az_code"`

	// 节点所在分片的名称
	GroupName string `json:"group_name"`

	// 诊断结果为异常的诊断项总数
	AbnormalSum int32 `json:"abnormal_sum"`

	// 诊断失败的诊断项总数
	FailedSum int32 `json:"failed_sum"`

	// 节点角色
	Role DiagnosisNodeReportRole `json:"role"`

	// 诊断维度列表
	DiagnosisDimensionList []DiagnosisDimension `json:"diagnosis_dimension_list"`

	CommandTimeTakenList *CommandTimeTakenList `json:"command_time_taken_list"`
}

DiagnosisNodeReport 节点诊断报告

func (DiagnosisNodeReport) String 

func (o DiagnosisNodeReport) String() string

type DiagnosisNodeReportRole 

type DiagnosisNodeReportRole struct {
	// contains filtered or unexported fields
}

func (DiagnosisNodeReportRole) MarshalJSON 

func (c DiagnosisNodeReportRole) MarshalJSON() ([]byte, error)

func (*DiagnosisNodeReportRole) UnmarshalJSON 

func (c *DiagnosisNodeReportRole) UnmarshalJSON(b []byte) error

func (DiagnosisNodeReportRole) Value 

func (c DiagnosisNodeReportRole) Value() string

type DiagnosisNodeReportRoleEnum 

type DiagnosisNodeReportRoleEnum struct {
	MASTER DiagnosisNodeReportRole
	SLAVE  DiagnosisNodeReportRole
}

func GetDiagnosisNodeReportRoleEnum 

func GetDiagnosisNodeReportRoleEnum() DiagnosisNodeReportRoleEnum

type DiagnosisReportInfo 

type DiagnosisReportInfo struct {

	// 诊断报告ID
	ReportId string `json:"report_id"`

	// 诊断任务状态
	Status DiagnosisReportInfoStatus `json:"status"`

	// 诊断时间段的开始时间。格式为：2017-03-31T12:24:46.297Z
	BeginTime string `json:"begin_time"`

	// 诊断时间段的结束时间。格式为：2017-03-31T12:24:46.297Z
	EndTime string `json:"end_time"`

	// 诊断报告创建时间
	CreatedAt string `json:"created_at"`

	// 参与诊断的节点个数
	NodeNum int32 `json:"node_num"`

	// 诊断结果为异常的诊断项总数
	AbnormalItemSum int32 `json:"abnormal_item_sum"`

	// 诊断失败的诊断项总数
	FailedItemSum int32 `json:"failed_item_sum"`
}

func (DiagnosisReportInfo) String 

func (o DiagnosisReportInfo) String() string

type DiagnosisReportInfoStatus 

type DiagnosisReportInfoStatus struct {
	// contains filtered or unexported fields
}

func (DiagnosisReportInfoStatus) MarshalJSON 

func (c DiagnosisReportInfoStatus) MarshalJSON() ([]byte, error)

func (*DiagnosisReportInfoStatus) UnmarshalJSON 

func (c *DiagnosisReportInfoStatus) UnmarshalJSON(b []byte) error

func (DiagnosisReportInfoStatus) Value 

func (c DiagnosisReportInfoStatus) Value() string

type DiagnosisReportInfoStatusEnum 

type DiagnosisReportInfoStatusEnum struct {
	DIAGNOSING DiagnosisReportInfoStatus
	FINISHED   DiagnosisReportInfoStatus
}

func GetDiagnosisReportInfoStatusEnum 

func GetDiagnosisReportInfoStatusEnum() DiagnosisReportInfoStatusEnum

type DimChild 

type DimChild struct {

	// 维度名称，当前支持维度有dcs_instance_id、dcs_cluster_redis_node、 dcs_cluster_proxy_node和dcs_memcached_instance_id。
	DimName *string `json:"dim_name,omitempty"`

	// 维度的路由，结构为主维度名称,当前维度名称，比如： dim_name字段为dcs_cluster_redis_node时，这个字段的值为dcs_instance_id,dcs_cluster_redis_node。
	DimRoute *string `json:"dim_route,omitempty"`
}

DimChild 维度对象结构体

func (DimChild) String 

func (o DimChild) String() string

type DomainNameEntity 

type DomainNameEntity struct {

	// 实例历史域名。
	DomainName *string `json:"domain_name,omitempty"`

	// 是否只读域名 - true：是 - false：否
	IsReadonly *bool `json:"is_readonly,omitempty"`
}

func (DomainNameEntity) String 

func (o DomainNameEntity) String() string

type DomainNameInfo 

type DomainNameInfo struct {

	// 是否开启公网域名解析。 - true：开启 - false：未开启
	SupportPublicResolve *bool `json:"support_public_resolve,omitempty"`

	// 当前域名是否已为最新。 - true：是 - false：否
	IsLatestRules *bool `json:"is_latest_rules,omitempty"`

	// 域名的区域后缀。
	ZoneName *string `json:"zone_name,omitempty"`

	// 历史域名信息。
	HistoryDomainNames *[]DomainNameEntity `json:"history_domain_names,omitempty"`
}

func (DomainNameInfo) String 

func (o DomainNameInfo) String() string

type DownloadBackupFilesReq 

type DownloadBackupFilesReq struct {

	// 设置URL的有效期，必须在5分钟和24小时之内，单位为秒。
	Expiration int32 `json:"expiration"`
}

func (DownloadBackupFilesReq) String 

func (o DownloadBackupFilesReq) String() string

type ExecuteClusterSwitchoverRequest 

type ExecuteClusterSwitchoverRequest struct {

	// 实例ID
	InstanceId string `json:"instance_id"`

	// 分片ID
	GroupId string `json:"group_id"`

	// 升级为主节点的节点ID
	NodeId string `json:"node_id"`
}

ExecuteClusterSwitchoverRequest Request Object

func (ExecuteClusterSwitchoverRequest) String 

func (o ExecuteClusterSwitchoverRequest) String() string

type ExecuteClusterSwitchoverResponse 

type ExecuteClusterSwitchoverResponse struct {

	// 集群分片倒换的任务ID
	JobId          *string `json:"job_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ExecuteClusterSwitchoverResponse Response Object

func (ExecuteClusterSwitchoverResponse) String 

func (o ExecuteClusterSwitchoverResponse) String() string

type Features 

type Features struct {

	// 是否支持acl - true：是 - false：否
	SupportAcl *bool `json:"support_acl,omitempty"`

	// 实例是否支持客户端ip透传 - true：是 - false：否
	SupportTransparentClientIp *bool `json:"support_transparent_client_ip,omitempty"`

	// 是否支持SSL - true：是 - false：否
	SupportSsl *bool `json:"support_ssl,omitempty"`
}

func (Features) String 

func (o Features) String() string

type Files 

type Files struct {

	// 备份文件名。
	FileName string `json:"file_name"`

	// 文件大小（单位：Byte）。
	Size *string `json:"size,omitempty"`

	// 文件最后修改时间（格式YYYY-MM-DD HH:MM:SS）。
	UpdateAt *string `json:"update_at,omitempty"`
}

Files 导入的备份文件文件列表。

func (Files) String 

func (o Files) String() string

type FlavorAzObject 

type FlavorAzObject struct {

	// 缓存容量（G Byte）。
	Capacity *string `json:"capacity,omitempty"`

	// 缓存容量单位。
	Unit *string `json:"unit,omitempty"`

	// 可用区信息。
	AvailableZones *[]string `json:"available_zones,omitempty"`

	// 有资源的可用区编码。
	AzCodes *[]string `json:"az_codes,omitempty"`
}

func (FlavorAzObject) String 

func (o FlavorAzObject) String() string

type FlavorsItems 

type FlavorsItems struct {

	// 产品规格编码。
	SpecCode *string `json:"spec_code,omitempty"`

	// 云服务类型编码。
	CloudServiceTypeCode *string `json:"cloud_service_type_code,omitempty"`

	// 云资源类型编码。
	CloudResourceTypeCode *string `json:"cloud_resource_type_code,omitempty"`

	// 缓存实例类型。取值范围如下： - single：表示单机实例 - ha：表示主备实例 - cluster：表示cluster集群实例 - proxy：表示Proxy集群实例 - ha_rw_split： 表示读写分离实例
	CacheMode *string `json:"cache_mode,omitempty"`

	// 缓存引擎类型。
	Engine *string `json:"engine,omitempty"`

	// 缓存版本，当缓存引擎为Redis时，取值为3.0、4.0或5.0。
	EngineVersion *string `json:"engine_version,omitempty"`

	// Redis缓存实例的产品类型。取值当前仅支持： generic：标准类型
	ProductType *string `json:"product_type,omitempty"`

	// CPU架构类型。取值范围如下： - x86_64：X86架构 - aarch64: ARM架构
	CpuType *string `json:"cpu_type,omitempty"`

	// 存储类型，取值当前仅支持： DRAM:内存存储
	StorageType *string `json:"storage_type,omitempty"`

	// 缓存容量（G Byte）。
	Capacity *[]string `json:"capacity,omitempty"`

	// 计费模式，取值范围如下： - Hourly：按需计费 - Monthly: 包月计费 - Yearly: 包周期计费
	BillingMode *[]string `json:"billing_mode,omitempty"`

	// 租户侧IP数量。
	TenantIpCount *int32 `json:"tenant_ip_count,omitempty"`

	// 定价类型，取值如下： - tier: 阶梯定价，一个规格对应多个容量 - normal: 规格和容量一一对应
	PricingType *string `json:"pricing_type,omitempty"`

	// 是否支持专属云。
	IsDec *bool `json:"is_dec,omitempty"`

	// 规格的其他信息。
	Attrs *[]AttrsObject `json:"attrs,omitempty"`

	// 有资源的可用区。
	FlavorsAvailableZones *[]FlavorAzObject `json:"flavors_available_zones,omitempty"`
}

func (FlavorsItems) String 

func (o FlavorsItems) String() string

type HistoryInfo 

type HistoryInfo struct {

	// 修改记录ID
	HistoryId *string `json:"history_id,omitempty"`

	// 修改类型
	Type *string `json:"type,omitempty"`

	// 修改时间
	CreatedAt *string `json:"created_at,omitempty"`

	// 修改状态
	Status *string `json:"status,omitempty"`
}

func (HistoryInfo) String 

func (o HistoryInfo) String() string

type HotkeysBody 

type HotkeysBody struct {

	// key名称
	Name *string `json:"name,omitempty"`

	// key类型
	Type *HotkeysBodyType `json:"type,omitempty"`

	// 热key所在的分片，仅在实例类型为集群时支持,格式为ip:port
	Shard *string `json:"shard,omitempty"`

	// 热key所在的db
	Db *int32 `json:"db,omitempty"`

	// key的value大小。
	Size *int64 `json:"size,omitempty"`

	// key大小的单位。type为string时，单位是：byte；type为list/set/zset/hash时，单位是：count
	Unit *string `json:"unit,omitempty"`

	// 表示某个key在一段时间的访问频度，会随着访问的频率而变化。  该值并不是简单的访问频率值，而是一个基于概率的对数计数器结果，最大为255(可表示100万次访问)，超过255后如果继续频繁访问该值并不会继续增大，同时默认如果每过一分钟没有访问，该值会衰减1。
	Freq *int32 `json:"freq,omitempty"`
}

HotkeysBody 热key记录结构体

func (HotkeysBody) String 

func (o HotkeysBody) String() string

type HotkeysBodyType 

type HotkeysBodyType struct {
	// contains filtered or unexported fields
}

func (HotkeysBodyType) MarshalJSON 

func (c HotkeysBodyType) MarshalJSON() ([]byte, error)

func (*HotkeysBodyType) UnmarshalJSON 

func (c *HotkeysBodyType) UnmarshalJSON(b []byte) error

func (HotkeysBodyType) Value 

func (c HotkeysBodyType) Value() string

type HotkeysBodyTypeEnum 

type HotkeysBodyTypeEnum struct {
	STRING HotkeysBodyType
	LIST   HotkeysBodyType
	SET    HotkeysBodyType
	ZSET   HotkeysBodyType
	HASH   HotkeysBodyType
}

func GetHotkeysBodyTypeEnum 

func GetHotkeysBodyTypeEnum() HotkeysBodyTypeEnum

type InstanceBackupPolicy 

type InstanceBackupPolicy struct {

	// 备份策略ID
	BackupPolicyId *string `json:"backup_policy_id,omitempty"`

	// 创建时间。格式为：2022-04-11T09:45:24.790Z
	CreatedAt *string `json:"created_at,omitempty"`

	// 更新时间。格式为：2022-04-12T02:22:03.269Z
	UpdatedAt *string `json:"updated_at,omitempty"`

	Policy *BackupPolicy `json:"policy,omitempty"`

	// 租户ID
	TenantId *string `json:"tenant_id,omitempty"`
}

func (InstanceBackupPolicy) String 

func (o InstanceBackupPolicy) String() string

type InstanceGroupListInfo 

type InstanceGroupListInfo struct {

	// 分片id
	GroupId *string `json:"group_id,omitempty"`

	// 分片名称
	GroupName *string `json:"group_name,omitempty"`

	// 每个分片包含的副本列表。
	ReplicationList *[]InstanceReplicationListInfo `json:"replication_list,omitempty"`
}

InstanceGroupListInfo 分片列表

func (InstanceGroupListInfo) String 

func (o InstanceGroupListInfo) String() string

type InstanceListInfo 

type InstanceListInfo struct {

	// Redis缓存实例绑定的弹性IP地址的id。 如果未开启公网访问功能，该字段值为null。
	PublicipId *string `json:"publicip_id,omitempty"`

	// VPC的名称。
	VpcName *string `json:"vpc_name,omitempty"`

	// 计费模式，0表示按需计费，1表示包年/包月计费。
	ChargingMode *int32 `json:"charging_mode,omitempty"`

	// VPC ID。
	VpcId *string `json:"vpc_id,omitempty"`

	// 子网ID。
	SubnetId *string `json:"subnet_id,omitempty"`

	// 安全组ID。
	SecurityGroupId *string `json:"security_group_id,omitempty"`

	// 创建时间。格式为：2017-03-31T12:24:46.297Z
	CreatedAt *string `json:"created_at,omitempty"`

	// 更新时间。格式为：2017-03-31T19:24:46.297Z
	UpdatedAt *string `json:"updated_at,omitempty"`

	// Redis缓存实例开启公网访问功能时，是否选择支持ssl。 - true：开启 - false：不开启
	EnableSsl *bool `json:"enable_ssl,omitempty"`

	// 总内存，单位：MB。
	MaxMemory *int32 `json:"max_memory,omitempty"`

	// 已使用的内存，单位：MB。
	UsedMemory *int32 `json:"used_memory,omitempty"`

	// Redis缓存实例绑定的弹性IP地址。 如果未开启公网访问功能，该字段值为null。
	PublicipAddress *string `json:"publicip_address,omitempty"`

	// 缓存容量（G Byte）。
	Capacity *int32 `json:"capacity,omitempty"`

	// 小规格缓存容量（G Byte）。
	CapacityMinor *string `json:"capacity_minor,omitempty"`

	// 订单ID，仅在创建包周期实例时返回。按需实例时此值为null
	OrderId *string `json:"order_id,omitempty"`

	// 维护时间窗开始时间，为UTC时间，格式为HH:mm:ss。
	MaintainBegin *string `json:"maintain_begin,omitempty"`

	// 维护时间窗结束时间，为UTC时间，格式为HH:mm:ss。
	MaintainEnd *string `json:"maintain_end,omitempty"`

	// 缓存引擎。
	Engine *string `json:"engine,omitempty"`

	// 缓存版本。
	EngineVersion *string `json:"engine_version,omitempty"`

	// 实例是否存在升级任务。 - true：存在 - false：不存在
	ServiceUpgrade *bool `json:"service_upgrade,omitempty"`

	// 是否允许免密码访问缓存实例。 - true：该实例无需密码即可访问。 - false：该实例必须通过密码认证才能访问。
	NoPasswordAccess *string `json:"no_password_access,omitempty"`

	// 升级任务的ID。 - 当service_upgrade为true时，为升级任务的ID。 - 当service_upgrade为false时，该参数为空。
	ServiceTaskId *string `json:"service_task_id,omitempty"`

	// 连接缓存实例的IP地址。如果是集群实例，返回多个IP地址，使用逗号分隔。如：192.168.0.1，192.168.0.2。
	Ip *string `json:"ip,omitempty"`

	// 通过密码认证访问缓存实例的认证用户名。
	AccessUser *string `json:"access_user,omitempty"`

	// 实例ID。
	InstanceId *string `json:"instance_id,omitempty"`

	// Redis缓存实例是否开启公网访问功能。 - true：开启 - false：不开启
	EnablePublicip *bool `json:"enable_publicip,omitempty"`

	// 缓存的端口。
	Port *int32 `json:"port,omitempty"`

	// 用户id。
	UserId *string `json:"user_id,omitempty"`

	// 用户名。
	UserName *string `json:"user_name,omitempty"`

	// 实例的域名。
	DomainName *string `json:"domain_name,omitempty"`

	// 实例的只读域名，只有主备实例有该字段。
	ReadonlyDomainName *string `json:"readonly_domain_name,omitempty"`

	// 实例名称。
	Name *string `json:"name,omitempty"`

	// 产品规格编码。
	SpecCode *string `json:"spec_code,omitempty"`

	// 实例状态。详细状态说明见[缓存实例状态说明](https://support.huaweicloud.com/api-dcs/dcs-api-0312047.html)。
	Status *string `json:"status,omitempty"`

	// 实例标签键值。
	Tags *[]ResourceTag `json:"tags,omitempty"`

	// 企业项目ID。
	EnterpriseProjectId *string `json:"enterprise_project_id,omitempty"`

	// 实例描述备注
	Description *string `json:"description,omitempty"`

	// 实例CPU类型，通常为x86_64或aarch64
	CpuType *string `json:"cpu_type,omitempty"`

	// 有资源的可用区编码。
	AzCodes *[]string `json:"az_codes,omitempty"`

	Features *Features `json:"features,omitempty"`

	// 实例子状态。
	SubStatus *string `json:"sub_status,omitempty"`
}

func (InstanceListInfo) String 

func (o InstanceListInfo) String() string

type InstanceNodesInfoResp 

type InstanceNodesInfoResp struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 当前实例节点总数
	NodeCount *int32 `json:"node_count,omitempty"`

	// 节点详情。
	Nodes *[]NodesInfoResp `json:"nodes,omitempty"`
}

InstanceNodesInfoResp 实例信息响应体

func (InstanceNodesInfoResp) String 

func (o InstanceNodesInfoResp) String() string

type InstanceReplicationDimensionsInfo 

type InstanceReplicationDimensionsInfo struct {

	// 监控维度名称
	Name *string `json:"name,omitempty"`

	// 维度取值
	Value *string `json:"value,omitempty"`
}

InstanceReplicationDimensionsInfo 监控指标维度对象信息

func (InstanceReplicationDimensionsInfo) String 

func (o InstanceReplicationDimensionsInfo) String() string

type InstanceReplicationListInfo 

type InstanceReplicationListInfo struct {

	// 副本角色，取值有： - master：表示主节点。 - slave：表示从节点。
	ReplicationRole *string `json:"replication_role,omitempty"`

	// 副本IP。
	ReplicationIp *string `json:"replication_ip,omitempty"`

	// 是否是新加副本。
	IsReplication *bool `json:"is_replication,omitempty"`

	// 副本id。
	ReplicationId *string `json:"replication_id,omitempty"`

	// 节点id。
	NodeId *string `json:"node_id,omitempty"`

	// 副本状态。
	Status *InstanceReplicationListInfoStatus `json:"status,omitempty"`

	// 副本所在的可用区
	AzCode *string `json:"az_code,omitempty"`

	// 副本对应的监控指标维度信息。可用于调用云监控服务的查询监控数据指标相关接口 - 副本的监控维度为多维度，返回数组中包含两个维度信息。从云监控查询监控数据时，要按多维度传递指标维度参数，才能查询到监控指标值 - 第一个维度为副本父维度信息，维度名称为dcs_instance_id，维度值对应副本所在的实例ID - 第二个维度，维度名称为dcs_cluster_redis_node,维度值为副本的监控对象ID，与副本ID和节点ID不同。
	Dimensions *[]InstanceReplicationDimensionsInfo `json:"dimensions,omitempty"`
}

InstanceReplicationListInfo 副本列表

func (InstanceReplicationListInfo) String 

func (o InstanceReplicationListInfo) String() string

type InstanceReplicationListInfoStatus 

type InstanceReplicationListInfoStatus struct {
	// contains filtered or unexported fields
}

func (InstanceReplicationListInfoStatus) MarshalJSON 

func (c InstanceReplicationListInfoStatus) MarshalJSON() ([]byte, error)

func (*InstanceReplicationListInfoStatus) UnmarshalJSON 

func (c *InstanceReplicationListInfoStatus) UnmarshalJSON(b []byte) error

func (InstanceReplicationListInfoStatus) Value 

func (c InstanceReplicationListInfoStatus) Value() string

type InstanceReplicationListInfoStatusEnum 

type InstanceReplicationListInfoStatusEnum struct {
	ACTIVE   InstanceReplicationListInfoStatus
	INACTIVE InstanceReplicationListInfoStatus
}

func GetInstanceReplicationListInfoStatusEnum 

func GetInstanceReplicationListInfoStatusEnum() InstanceReplicationListInfoStatusEnum

type InstanceRestoreInfo 

type InstanceRestoreInfo struct {

	// 备份记录ID。
	BackupId *string `json:"backup_id,omitempty"`

	// 恢复记录ID。
	RestoreId *string `json:"restore_id,omitempty"`

	// 备份记录名称。
	BackupName *string `json:"backup_name,omitempty"`

	// 恢复完成时间。
	UpdatedAt *string `json:"updated_at,omitempty"`

	// 恢复备注信息。
	RestoreRemark *string `json:"restore_remark,omitempty"`

	// 恢复任务创建时间。
	CreatedAt *string `json:"created_at,omitempty"`

	// 恢复进度。
	Progress *string `json:"progress,omitempty"`

	// 恢复失败后错误码 * `dcs.08.0001` - 启动备份恢复工具失败。 * `dcs.08.0002` - 执行超时。 * `dcs.08.0003` - 删除桶失败。 * `dcs.08.0004` - 获取ak/sk 失败。 * `dcs.08.0005` - 创建桶失败。 * `dcs.08.0006` - 查询备份数据大小失败。 * `dcs.08.0007` - 恢复时同步数据失败。 * `dcs.08.0008` - 自动备份任务未运行，实例正在运行其他任务。
	ErrorCode *string `json:"error_code,omitempty"`

	// 恢复记录名称。
	RestoreName *string `json:"restore_name,omitempty"`

	// 备份备注信息。
	BackupRemark *string `json:"backup_remark,omitempty"`

	// 恢复状态。 - waiting：等待中 - restoring：恢复中 - succeed：恢复成功 - failed：恢复失败
	Status *InstanceRestoreInfoStatus `json:"status,omitempty"`
}

func (InstanceRestoreInfo) String 

func (o InstanceRestoreInfo) String() string

type InstanceRestoreInfoStatus 

type InstanceRestoreInfoStatus struct {
	// contains filtered or unexported fields
}

func (InstanceRestoreInfoStatus) MarshalJSON 

func (c InstanceRestoreInfoStatus) MarshalJSON() ([]byte, error)

func (*InstanceRestoreInfoStatus) UnmarshalJSON 

func (c *InstanceRestoreInfoStatus) UnmarshalJSON(b []byte) error

func (InstanceRestoreInfoStatus) Value 

func (c InstanceRestoreInfoStatus) Value() string

type InstanceRestoreInfoStatusEnum 

type InstanceRestoreInfoStatusEnum struct {
	WAITING   InstanceRestoreInfoStatus
	RESTORING InstanceRestoreInfoStatus
	SUCCEED   InstanceRestoreInfoStatus
	FAILED    InstanceRestoreInfoStatus
}

func GetInstanceRestoreInfoStatusEnum 

func GetInstanceRestoreInfoStatusEnum() InstanceRestoreInfoStatusEnum

type InstanceStatistic 

type InstanceStatistic struct {

	// 缓存实例网络入流量，单位：Kbps。
	InputKbps *string `json:"input_kbps,omitempty"`

	// 缓存实例网络出流量，单位：Kbps。
	OutputKbps *string `json:"output_kbps,omitempty"`

	// 实例ID。
	InstanceId *string `json:"instance_id,omitempty"`

	// 缓存存储的数据条数。
	Keys *int64 `json:"keys,omitempty"`

	// 缓存已经使用内存，单位：MB。
	UsedMemory *int64 `json:"used_memory,omitempty"`

	// 缓存的总内存，单位：MB。
	MaxMemory *int64 `json:"max_memory,omitempty"`

	// 缓存get命令被调用次数。
	CmdGetCount *int64 `json:"cmd_get_count,omitempty"`

	// 缓存set命令被调用次数。
	CmdSetCount *int64 `json:"cmd_set_count,omitempty"`

	// CPU使用率，单位：百分比。
	UsedCpu *string `json:"used_cpu,omitempty"`
}

InstanceStatistic 实例的统计信息。

func (InstanceStatistic) String 

func (o InstanceStatistic) String() string

type Instances 

type Instances struct {

	// 缓存实例ID。
	InstanceId *string `json:"instance_id,omitempty"`

	// 缓存实例名称。
	InstanceName *string `json:"instance_name,omitempty"`
}

func (Instances) String 

func (o Instances) String() string

type InstancesMonitoredObject 

type InstancesMonitoredObject struct {

	// 测量对象ID，即实例的ID。
	DcsInstanceId *string `json:"dcs_instance_id,omitempty"`

	// 测量对象名称，即实例名称。
	Name *string `json:"name,omitempty"`

	// 测量对象状态，即实例状态。
	Status *string `json:"status,omitempty"`
}

InstancesMonitoredObject 监控对象结构

func (InstancesMonitoredObject) String 

func (o InstancesMonitoredObject) String() string

type LinksItem 

type LinksItem struct {

	// 备份文件名称。
	FileName *string `json:"file_name,omitempty"`

	// 备份文件下载链接地址。
	Link *string `json:"link,omitempty"`
}

func (LinksItem) String 

func (o LinksItem) String() string

type ListAvailableZonesRequest 

type ListAvailableZonesRequest struct {
}

ListAvailableZonesRequest Request Object

func (ListAvailableZonesRequest) String 

func (o ListAvailableZonesRequest) String() string

type ListAvailableZonesResponse 

type ListAvailableZonesResponse struct {

	// 区域ID。
	RegionId *string `json:"region_id,omitempty"`

	// 可用分区数组。
	AvailableZones *[]AvailableZones `json:"available_zones,omitempty"`
	HttpStatusCode int               `json:"-"`
}

ListAvailableZonesResponse Response Object

func (ListAvailableZonesResponse) String 

func (o ListAvailableZonesResponse) String() string

type ListBackgroundTaskRequest 

type ListBackgroundTaskRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 查询开始时间，时间为UTC时间。格式：yyyyMMddHHmmss，如：20200609160000。
	StartTime *string `json:"start_time,omitempty"`

	// 查询结束时间，时间为UTC时间。格式：yyyyMMddHHmmss，如：20200617155959。
	EndTime *string `json:"end_time,omitempty"`
}

ListBackgroundTaskRequest Request Object

func (ListBackgroundTaskRequest) String 

func (o ListBackgroundTaskRequest) String() string

type ListBackgroundTaskResponse 

type ListBackgroundTaskResponse struct {

	// 任务个数
	TaskCount *string `json:"task_count,omitempty"`

	// 任务详情数组
	Tasks          *[]SingleBackgroundTask `json:"tasks,omitempty"`
	HttpStatusCode int                     `json:"-"`
}

ListBackgroundTaskResponse Response Object

func (ListBackgroundTaskResponse) String 

func (o ListBackgroundTaskResponse) String() string

type ListBackupFileLinksRequest 

type ListBackupFileLinksRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 备份记录ID。
	BackupId string `json:"backup_id"`

	Body *DownloadBackupFilesReq `json:"body,omitempty"`
}

ListBackupFileLinksRequest Request Object

func (ListBackupFileLinksRequest) String 

func (o ListBackupFileLinksRequest) String() string

type ListBackupFileLinksResponse 

type ListBackupFileLinksResponse struct {

	// OBS桶内文件路径。
	FilePath *string `json:"file_path,omitempty"`

	// OBS桶名。
	BucketName *string `json:"bucket_name,omitempty"`

	// 备份文件下链接集合，链接数最大为64个。
	Links          *[]LinksItem `json:"links,omitempty"`
	HttpStatusCode int          `json:"-"`
}

ListBackupFileLinksResponse Response Object

func (ListBackupFileLinksResponse) String 

func (o ListBackupFileLinksResponse) String() string

type ListBackupRecordsRequest 

type ListBackupRecordsRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 查询开始时间，时间为UTC时间。格式：yyyyMMddHHmmss，如：20170718235959。
	BeginTime *string `json:"begin_time,omitempty"`

	// 查询结束时间，时间为UTC时间。格式：yyyyMMddHHmmss，如：20170718235959。
	EndTime *string `json:"end_time,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0。
	Offset *int32 `json:"offset,omitempty"`
}

ListBackupRecordsRequest Request Object

func (ListBackupRecordsRequest) String 

func (o ListBackupRecordsRequest) String() string

type ListBackupRecordsResponse 

type ListBackupRecordsResponse struct {

	// 返回记录数。
	TotalNum *int32 `json:"total_num,omitempty"`

	// 备份信息的详情数组。
	BackupRecordResponse *[]BackupRecordResponse `json:"backup_record_response,omitempty"`
	HttpStatusCode       int                     `json:"-"`
}

ListBackupRecordsResponse Response Object

func (ListBackupRecordsResponse) String 

func (o ListBackupRecordsResponse) String() string

type ListBigkeyScanTasksRequest 

type ListBigkeyScanTasksRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 分析任务状态
	Status *ListBigkeyScanTasksRequestStatus `json:"status,omitempty"`
}

ListBigkeyScanTasksRequest Request Object

func (ListBigkeyScanTasksRequest) String 

func (o ListBigkeyScanTasksRequest) String() string

type ListBigkeyScanTasksRequestStatus 

type ListBigkeyScanTasksRequestStatus struct {
	// contains filtered or unexported fields
}

func (ListBigkeyScanTasksRequestStatus) MarshalJSON 

func (c ListBigkeyScanTasksRequestStatus) MarshalJSON() ([]byte, error)

func (*ListBigkeyScanTasksRequestStatus) UnmarshalJSON 

func (c *ListBigkeyScanTasksRequestStatus) UnmarshalJSON(b []byte) error

func (ListBigkeyScanTasksRequestStatus) Value 

func (c ListBigkeyScanTasksRequestStatus) Value() string

type ListBigkeyScanTasksRequestStatusEnum 

type ListBigkeyScanTasksRequestStatusEnum struct {
	WAITING ListBigkeyScanTasksRequestStatus
	RUNNING ListBigkeyScanTasksRequestStatus
	SUCCESS ListBigkeyScanTasksRequestStatus
	FAILED  ListBigkeyScanTasksRequestStatus
}

func GetListBigkeyScanTasksRequestStatusEnum 

func GetListBigkeyScanTasksRequestStatusEnum() ListBigkeyScanTasksRequestStatusEnum

type ListBigkeyScanTasksResponse 

type ListBigkeyScanTasksResponse struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 总数
	Count *int32 `json:"count,omitempty"`

	// 大key分析记录列表
	Records        *[]RecordsResponse `json:"records,omitempty"`
	HttpStatusCode int                `json:"-"`
}

ListBigkeyScanTasksResponse Response Object

func (ListBigkeyScanTasksResponse) String 

func (o ListBigkeyScanTasksResponse) String() string

type ListConfigHistoriesRequest 

type ListConfigHistoriesRequest struct {

	// 实例ID
	InstanceId string `json:"instance_id"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示条数，最小值为1，最大值为1000，若不设置该参数，则为10。
	Limit *int32 `json:"limit,omitempty"`
}

ListConfigHistoriesRequest Request Object

func (ListConfigHistoriesRequest) String 

func (o ListConfigHistoriesRequest) String() string

type ListConfigHistoriesResponse 

type ListConfigHistoriesResponse struct {

	// 实例参数修改记录个数
	HistoryNum *int32 `json:"history_num,omitempty"`

	// 实力参数修改记录详情
	Histories      *[]HistoryInfo `json:"histories,omitempty"`
	HttpStatusCode int            `json:"-"`
}

ListConfigHistoriesResponse Response Object

func (ListConfigHistoriesResponse) String 

func (o ListConfigHistoriesResponse) String() string

type ListConfigTemplatesRequest 

type ListConfigTemplatesRequest struct {

	// 参数模板名称，支持模糊查找
	Name *string `json:"name,omitempty"`

	// 模板ID
	TemplateId *string `json:"template_id,omitempty"`

	// 模板类型
	Type ListConfigTemplatesRequestType `json:"type"`

	// 缓存引擎：Redis[和Memcached](tag:hws,hws_hk,ocb,sbc,tm,ctc,cmcc)。
	Engine *string `json:"engine,omitempty"`

	// 缓存版本。  当缓存引擎为Redis时，取值为[3.0/4.0/5.0](tag:ctc,cmc)[3.0/4.0/5.0/6.0](tag:ocb,otc,sbc,g42,tm)[4.0/5.0/6.0](tag:hws,hws_hk)。  [当缓存引擎为Memcached时，该字段为可选，取值为空。](tag:hws,hws_hk,ocb,sbc,tm,ctc,cmcc)
	EngineVersion *string `json:"engine_version,omitempty"`

	// 缓存实例类型。取值范围如下： - single：表示单机实例 - ha：表示主备实例 - cluster：表示cluster集群实例 - proxy：表示Proxy集群实例 [- ha_rw_split：表示读写分离实例](tag:hws)
	CacheMode *string `json:"cache_mode,omitempty"`

	// 模板的描述信息
	Description *string `json:"description,omitempty"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示条数，最小值为1，最大值为1000，若不设置该参数，则为10。
	Limit *int32 `json:"limit,omitempty"`
}

ListConfigTemplatesRequest Request Object

func (ListConfigTemplatesRequest) String 

func (o ListConfigTemplatesRequest) String() string

type ListConfigTemplatesRequestType 

type ListConfigTemplatesRequestType struct {
	// contains filtered or unexported fields
}

func (ListConfigTemplatesRequestType) MarshalJSON 

func (c ListConfigTemplatesRequestType) MarshalJSON() ([]byte, error)

func (*ListConfigTemplatesRequestType) UnmarshalJSON 

func (c *ListConfigTemplatesRequestType) UnmarshalJSON(b []byte) error

func (ListConfigTemplatesRequestType) Value 

func (c ListConfigTemplatesRequestType) Value() string

type ListConfigTemplatesRequestTypeEnum 

type ListConfigTemplatesRequestTypeEnum struct {
	SYS  ListConfigTemplatesRequestType
	USER ListConfigTemplatesRequestType
}

func GetListConfigTemplatesRequestTypeEnum 

func GetListConfigTemplatesRequestTypeEnum() ListConfigTemplatesRequestTypeEnum

type ListConfigTemplatesResponse 

type ListConfigTemplatesResponse struct {

	// 模板个数。
	TemplateNum *int32 `json:"template_num,omitempty"`

	// 模板的详情数组。
	ConfigTemplates *[]ConfigTemplatesListInfo `json:"config_templates,omitempty"`
	HttpStatusCode  int                        `json:"-"`
}

ListConfigTemplatesResponse Response Object

func (ListConfigTemplatesResponse) String 

func (o ListConfigTemplatesResponse) String() string

type ListConfigurationsRequest 

type ListConfigurationsRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

ListConfigurationsRequest Request Object

func (ListConfigurationsRequest) String 

func (o ListConfigurationsRequest) String() string

type ListConfigurationsResponse 

type ListConfigurationsResponse struct {

	// 实例操作时间。格式为：2017-03-31T12:24:46.297Z
	ConfigTime *string `json:"config_time,omitempty"`

	// 实例ID。
	InstanceId *string `json:"instance_id,omitempty"`

	// 实例配置项数组。
	RedisConfig *[]QueryRedisConfig `json:"redis_config,omitempty"`

	// 实例修改状态 - UPDATING - FAILURE - SUCCESS
	ConfigStatus *ListConfigurationsResponseConfigStatus `json:"config_status,omitempty"`

	// 实例运行状态。
	Status         *string `json:"status,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ListConfigurationsResponse Response Object

func (ListConfigurationsResponse) String 

func (o ListConfigurationsResponse) String() string

type ListConfigurationsResponseConfigStatus 

type ListConfigurationsResponseConfigStatus struct {
	// contains filtered or unexported fields
}

func (ListConfigurationsResponseConfigStatus) MarshalJSON 

func (c ListConfigurationsResponseConfigStatus) MarshalJSON() ([]byte, error)

func (*ListConfigurationsResponseConfigStatus) UnmarshalJSON 

func (c *ListConfigurationsResponseConfigStatus) UnmarshalJSON(b []byte) error

func (ListConfigurationsResponseConfigStatus) Value 

func (c ListConfigurationsResponseConfigStatus) Value() string

type ListConfigurationsResponseConfigStatusEnum 

type ListConfigurationsResponseConfigStatusEnum struct {
	UPDATING ListConfigurationsResponseConfigStatus
	FAILURE  ListConfigurationsResponseConfigStatus
	SUCCESS  ListConfigurationsResponseConfigStatus
}

func GetListConfigurationsResponseConfigStatusEnum 

func GetListConfigurationsResponseConfigStatusEnum() ListConfigurationsResponseConfigStatusEnum

type ListDiagnosisTasksRequest 

type ListDiagnosisTasksRequest struct {

	// 实例ID
	InstanceId string `json:"instance_id"`

	// 每页显示条数，最小值为1，最大值为1000，若不设置该参数，则为10。
	Limit *int32 `json:"limit,omitempty"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0。
	Offset *int32 `json:"offset,omitempty"`
}

ListDiagnosisTasksRequest Request Object

func (ListDiagnosisTasksRequest) String 

func (o ListDiagnosisTasksRequest) String() string

type ListDiagnosisTasksResponse 

type ListDiagnosisTasksResponse struct {

	// 诊断报告列表
	DiagnosisReportList *[]DiagnosisReportInfo `json:"diagnosis_report_list,omitempty"`

	// 诊断报告总数
	TotalNum       *int32 `json:"total_num,omitempty"`
	HttpStatusCode int    `json:"-"`
}

ListDiagnosisTasksResponse Response Object

func (ListDiagnosisTasksResponse) String 

func (o ListDiagnosisTasksResponse) String() string

type ListFlavorsRequest 

type ListFlavorsRequest struct {

	// 缓存实例ID，根据该字段可查询出实例可变更的规格
	InstanceId *string `json:"instance_id,omitempty"`

	// 产品规格编码。
	SpecCode *string `json:"spec_code,omitempty"`

	// 缓存实例类型。取值范围如下： - single：表示单机实例 - ha：表示主备实例 - cluster：表示cluster集群实例 - proxy：表示Proxy集群实例 - ha_rw_split： 表示读写分离实例
	CacheMode *string `json:"cache_mode,omitempty"`

	// 缓存引擎类型。取值范围如下： - Redis - Memcached
	Engine *string `json:"engine,omitempty"`

	// 缓存版本，当缓存引擎为Redis时，取值范围如下： - 3.0 - 4.0 - 5.0
	EngineVersion *string `json:"engine_version,omitempty"`

	// CPU架构类型。取值范围如下： - x86_64：X86架构 - aarch64：ARM架构
	CpuType *ListFlavorsRequestCpuType `json:"cpu_type,omitempty"`

	// 缓存容量（G Byte）。 - Redis3.0：单机和主备类型实例取值：2、4、8、16、32、64。Proxy集群实例规格支持64、128、256、512和1024。 - Redis4.0和Redis5.0：单机和主备类型实例取值：0.125、0.25、0.5、1、2、4、8、16、32、64。Cluster集群实例规格支持24、32、48、64、96、128、192、256、384、512、768、1024。 - Memcached：单机和主备类型实例取值：2、4、8、16、32、64。
	Capacity *string `json:"capacity,omitempty"`
}

ListFlavorsRequest Request Object

func (ListFlavorsRequest) String 

func (o ListFlavorsRequest) String() string

type ListFlavorsRequestCpuType 

type ListFlavorsRequestCpuType struct {
	// contains filtered or unexported fields
}

func (ListFlavorsRequestCpuType) MarshalJSON 

func (c ListFlavorsRequestCpuType) MarshalJSON() ([]byte, error)

func (*ListFlavorsRequestCpuType) UnmarshalJSON 

func (c *ListFlavorsRequestCpuType) UnmarshalJSON(b []byte) error

func (ListFlavorsRequestCpuType) Value 

func (c ListFlavorsRequestCpuType) Value() string

type ListFlavorsRequestCpuTypeEnum 

type ListFlavorsRequestCpuTypeEnum struct {
	X86_64  ListFlavorsRequestCpuType
	AARCH64 ListFlavorsRequestCpuType
}

func GetListFlavorsRequestCpuTypeEnum 

func GetListFlavorsRequestCpuTypeEnum() ListFlavorsRequestCpuTypeEnum

type ListFlavorsResponse 

type ListFlavorsResponse struct {

	// 产品规格详情。
	Flavors        *[]FlavorsItems `json:"flavors,omitempty"`
	HttpStatusCode int             `json:"-"`
}

ListFlavorsResponse Response Object

func (ListFlavorsResponse) String 

func (o ListFlavorsResponse) String() string

type ListGroupReplicationInfoRequest 

type ListGroupReplicationInfoRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

ListGroupReplicationInfoRequest Request Object

func (ListGroupReplicationInfoRequest) String 

func (o ListGroupReplicationInfoRequest) String() string

type ListGroupReplicationInfoResponse 

type ListGroupReplicationInfoResponse struct {

	// 分片列表
	GroupList *[]InstanceGroupListInfo `json:"group_list,omitempty"`

	// 实例分片总数。
	GroupCount     *int32 `json:"group_count,omitempty"`
	HttpStatusCode int    `json:"-"`
}

ListGroupReplicationInfoResponse Response Object

func (ListGroupReplicationInfoResponse) String 

func (o ListGroupReplicationInfoResponse) String() string

type ListHotKeyScanTasksRequest 

type ListHotKeyScanTasksRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 分析任务状态
	Status *ListHotKeyScanTasksRequestStatus `json:"status,omitempty"`
}

ListHotKeyScanTasksRequest Request Object

func (ListHotKeyScanTasksRequest) String 

func (o ListHotKeyScanTasksRequest) String() string

type ListHotKeyScanTasksRequestStatus 

type ListHotKeyScanTasksRequestStatus struct {
	// contains filtered or unexported fields
}

func (ListHotKeyScanTasksRequestStatus) MarshalJSON 

func (c ListHotKeyScanTasksRequestStatus) MarshalJSON() ([]byte, error)

func (*ListHotKeyScanTasksRequestStatus) UnmarshalJSON 

func (c *ListHotKeyScanTasksRequestStatus) UnmarshalJSON(b []byte) error

func (ListHotKeyScanTasksRequestStatus) Value 

func (c ListHotKeyScanTasksRequestStatus) Value() string

type ListHotKeyScanTasksRequestStatusEnum 

type ListHotKeyScanTasksRequestStatusEnum struct {
	WAITING ListHotKeyScanTasksRequestStatus
	RUNNING ListHotKeyScanTasksRequestStatus
	SUCCESS ListHotKeyScanTasksRequestStatus
	FAILED  ListHotKeyScanTasksRequestStatus
}

func GetListHotKeyScanTasksRequestStatusEnum 

func GetListHotKeyScanTasksRequestStatusEnum() ListHotKeyScanTasksRequestStatusEnum

type ListHotKeyScanTasksResponse 

type ListHotKeyScanTasksResponse struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 总数
	Count *int32 `json:"count,omitempty"`

	// 热key分析记录列表
	Records        *[]RecordsResponse `json:"records,omitempty"`
	HttpStatusCode int                `json:"-"`
}

ListHotKeyScanTasksResponse Response Object

func (ListHotKeyScanTasksResponse) String 

func (o ListHotKeyScanTasksResponse) String() string

type ListInstancesRequest 

type ListInstancesRequest struct {

	// 实例ID。
	InstanceId *string `json:"instance_id,omitempty"`

	// 是否返回创建失败的实例数。 当参数值为“true”时，返回创建失败的实例数。参数值为“false”或者其他值，不返回创建失败的实例数。
	IncludeFailure *string `json:"include_failure,omitempty"`

	// 是否返回已删除的实例数。 当参数值为“true”时，返回已删除的实例数。参数值为“false”或者其他值，不返回已删除的实例数。
	IncludeDelete *string `json:"include_delete,omitempty"`

	// 实例名称。
	Name *string `json:"name,omitempty"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示条数，最小值为1，最大值为1000，若不设置该参数，则为10。
	Limit *int32 `json:"limit,omitempty"`

	// 实例状态。详细状态说明见[缓存实例状态说明](https://support.huaweicloud.com/api-dcs/dcs-api-0312047.html)
	Status *string `json:"status,omitempty"`

	// 是否按照实例名称进行精确匹配查询。  和name字段对应，name字段为模糊匹配的用例名，name_equal是精确匹配的用例名。
	NameEqual *string `json:"name_equal,omitempty"`

	// 根据实例标签键值对进行查询。{key}表示标签键，{value}表示标签值。  如果同时使用多个标签键值对进行查询，中间使用逗号分隔开，表示查询同时包含指定标签键值对的实例。
	Tags *string `json:"tags,omitempty"`

	// 连接缓存实例的IP地址。
	Ip *string `json:"ip,omitempty"`
}

ListInstancesRequest Request Object

func (ListInstancesRequest) String 

func (o ListInstancesRequest) String() string

type ListInstancesResponse 

type ListInstancesResponse struct {

	// 实例个数。
	InstanceNum *int32 `json:"instance_num,omitempty"`

	// 实例的详情数组。
	Instances      *[]InstanceListInfo `json:"instances,omitempty"`
	HttpStatusCode int                 `json:"-"`
}

ListInstancesResponse Response Object

func (ListInstancesResponse) String 

func (o ListInstancesResponse) String() string

type ListMaintenanceWindowsRequest 

type ListMaintenanceWindowsRequest struct {
}

ListMaintenanceWindowsRequest Request Object

func (ListMaintenanceWindowsRequest) String 

func (o ListMaintenanceWindowsRequest) String() string

type ListMaintenanceWindowsResponse 

type ListMaintenanceWindowsResponse struct {

	// 支持的维护时间窗列表。
	MaintainWindows *[]MaintainWindowsEntity `json:"maintain_windows,omitempty"`
	HttpStatusCode  int                      `json:"-"`
}

ListMaintenanceWindowsResponse Response Object

func (ListMaintenanceWindowsResponse) String 

func (o ListMaintenanceWindowsResponse) String() string

type ListMigrationTaskRequest 

type ListMigrationTaskRequest struct {

	// 偏移量，表示从此偏移量开始查询， offset大于等于0。
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 迁移任务名称。
	Name *string `json:"name,omitempty"`
}

ListMigrationTaskRequest Request Object

func (ListMigrationTaskRequest) String 

func (o ListMigrationTaskRequest) String() string

type ListMigrationTaskResponse 

type ListMigrationTaskResponse struct {

	// 迁移任务数量。
	Count *int32 `json:"count,omitempty"`

	// 迁移任务列表。
	MigrationTasks *[]MigrationTaskList `json:"migration_tasks,omitempty"`
	HttpStatusCode int                  `json:"-"`
}

ListMigrationTaskResponse Response Object

func (ListMigrationTaskResponse) String 

func (o ListMigrationTaskResponse) String() string

type ListMonitoredObjectsOfInstanceRequest 

type ListMonitoredObjectsOfInstanceRequest struct {

	// 主维度对象ID，与DCS实例列表中实例ID相同。
	InstanceId string `json:"instance_id"`

	// 主维度ID，当前支持子维度的主维度ID的有dcs_instance_id。
	DimName string `json:"dim_name"`
}

ListMonitoredObjectsOfInstanceRequest Request Object

func (ListMonitoredObjectsOfInstanceRequest) String 

func (o ListMonitoredObjectsOfInstanceRequest) String() string

type ListMonitoredObjectsOfInstanceResponse 

type ListMonitoredObjectsOfInstanceResponse struct {

	// 当前查询维度路由。如果是主维度，则数组中是自身ID。
	Router *[]string `json:"router,omitempty"`

	// 当前查询维度子维度对象列表。当前只有维度为dcs_instance_id时才有值。 - Proxy集群有两个子维度，分别为dcs_cluster_redis_node和dcs_cluster_proxy_node。 - Cluster集群有一个子维度 dcs_cluster_proxy_node。
	Children *[]DimChild `json:"children,omitempty"`

	// 当前查询维度监控对象列表。
	Instances *[]InstancesMonitoredObject `json:"instances,omitempty"`

	// Proxy集群或Cluster集群时才存在，表示集群数据节点维度的监控对象列表。字段名称与children的子维度对象名称相同。
	DcsClusterRedisNode *[]ClusterRedisNodeMonitoredObject `json:"dcs_cluster_redis_node,omitempty"`

	// Proxy集群时才存在，表示集群Proxy节点维度的监控对象列表。字段名称与children的子维度对象名称相同。
	DcsClusterProxyNode *[]ProxyNodeMonitoredObject `json:"dcs_cluster_proxy_node,omitempty"`

	// Redis 4.0和5.0的Proxy集群时才存在，表示集群Proxy节点维度的监控对象列表。字段名称与children的子维度对象名称相同。
	DcsClusterProxy2Node *[]Proxy2NodeMonitoredObject `json:"dcs_cluster_proxy2_node,omitempty"`

	// 主维度监控对象的总数。
	Total          *int32 `json:"total,omitempty"`
	HttpStatusCode int    `json:"-"`
}

ListMonitoredObjectsOfInstanceResponse Response Object

func (ListMonitoredObjectsOfInstanceResponse) String 

func (o ListMonitoredObjectsOfInstanceResponse) String() string

type ListMonitoredObjectsRequest 

type ListMonitoredObjectsRequest struct {

	// 主维度ID，当前支持dcs_instance_id，dcs_memcached_instance_id。
	DimName string `json:"dim_name"`

	// 偏移量，表示从此偏移量开始查询，offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示的条目数量
	Limit *int32 `json:"limit,omitempty"`
}

ListMonitoredObjectsRequest Request Object

func (ListMonitoredObjectsRequest) String 

func (o ListMonitoredObjectsRequest) String() string

type ListMonitoredObjectsResponse 

type ListMonitoredObjectsResponse struct {

	// 当前查询维度路由。如果是主维度，则数组中是自身ID。
	Router *[]string `json:"router,omitempty"`

	// 当前查询维度子维度对象列表。当前只有维度为dcs_instance_id时才有值。 - Proxy集群有两个子维度，分别为dcs_cluster_redis_node和dcs_cluster_proxy_node。 - Cluster集群有一个子维度 dcs_cluster_proxy_node。
	Children *[]DimChild `json:"children,omitempty"`

	// 当前查询维度监控对象列表。
	Instances *[]InstancesMonitoredObject `json:"instances,omitempty"`

	// 主维度监控对象的总数。
	Total          *int32 `json:"total,omitempty"`
	HttpStatusCode int    `json:"-"`
}

ListMonitoredObjectsResponse Response Object

func (ListMonitoredObjectsResponse) String 

func (o ListMonitoredObjectsResponse) String() string

type ListNumberOfInstancesInDifferentStatusRequest 

type ListNumberOfInstancesInDifferentStatusRequest struct {

	// 是否返回创建失败的实例数。   - 当参数值为“true”时，返回的统计包括创建失败的实例数。   - 参数值为“false”或者其他值，返回的统计不包括创建失败的实例数。
	IncludeFailure *string `json:"include_failure,omitempty"`
}

ListNumberOfInstancesInDifferentStatusRequest Request Object

func (ListNumberOfInstancesInDifferentStatusRequest) String 

func (o ListNumberOfInstancesInDifferentStatusRequest) String() string

type ListNumberOfInstancesInDifferentStatusResponse 

type ListNumberOfInstancesInDifferentStatusResponse struct {
	Redis *StatusStatistic `json:"redis,omitempty"`

	Memcached *StatusStatistic `json:"memcached,omitempty"`

	// 支付中的实例数。
	PayingCount *int32 `json:"paying_count,omitempty"`

	// 冻结中的实例数。
	FreezingCount *int32 `json:"freezing_count,omitempty"`

	// 迁移中的实例数。
	MigratingCount *int32 `json:"migrating_count,omitempty"`

	// 清空中的实例数。
	FlushingCount *int32 `json:"flushing_count,omitempty"`

	// 升级中的实例数。
	UpgradingCount *int32 `json:"upgrading_count,omitempty"`

	// 恢复中的实例数。
	RestoringCount *int32 `json:"restoring_count,omitempty"`

	// 扩容中的实例数。
	ExtendingCount *int32 `json:"extending_count,omitempty"`

	// 正在创建的实例数。
	CreatingCount *int32 `json:"creating_count,omitempty"`

	// 正在运行的实例数。
	RunningCount *int32 `json:"running_count,omitempty"`

	// 异常的实例数。
	ErrorCount *int32 `json:"error_count,omitempty"`

	// 已冻结的实例数。
	FrozenCount *int32 `json:"frozen_count,omitempty"`

	// 创建失败的实例数。
	CreatefailedCount *int32 `json:"createfailed_count,omitempty"`

	// 正在重启的实例数。
	RestartingCount *int32 `json:"restarting_count,omitempty"`
	HttpStatusCode  int    `json:"-"`
}

ListNumberOfInstancesInDifferentStatusResponse Response Object

func (ListNumberOfInstancesInDifferentStatusResponse) String 

func (o ListNumberOfInstancesInDifferentStatusResponse) String() string

type ListRedislogRequest 

type ListRedislogRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 返回日志的类型，当前仅支持Redis运行日志，类型为run
	LogType string `json:"log_type"`
}

ListRedislogRequest Request Object

func (ListRedislogRequest) String 

func (o ListRedislogRequest) String() string

type ListRedislogResponse 

type ListRedislogResponse struct {

	// 总数
	TotalNum *int32 `json:"total_num,omitempty"`

	// 运行日志列表
	FileList       *[]RunlogItem `json:"file_list,omitempty"`
	HttpStatusCode int           `json:"-"`
}

ListRedislogResponse Response Object

func (ListRedislogResponse) String 

func (o ListRedislogResponse) String() string

type ListRestoreRecordsRequest 

type ListRestoreRecordsRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 查询开始时间。格式：yyyyMMddHHmmss，如：20170718235959。
	BeginTime *string `json:"begin_time,omitempty"`

	// 查询结束时间。格式：yyyyMMddHHmmss，如：20170718235959。
	EndTime *string `json:"end_time,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0。
	Offset *int32 `json:"offset,omitempty"`
}

ListRestoreRecordsRequest Request Object

func (ListRestoreRecordsRequest) String 

func (o ListRestoreRecordsRequest) String() string

type ListRestoreRecordsResponse 

type ListRestoreRecordsResponse struct {

	// 实例恢复记录的详情数组。
	RestoreRecordResponse *[]InstanceRestoreInfo `json:"restore_record_response,omitempty"`

	// 返回记录数。
	TotalNum       *int32 `json:"total_num,omitempty"`
	HttpStatusCode int    `json:"-"`
}

ListRestoreRecordsResponse Response Object

func (ListRestoreRecordsResponse) String 

func (o ListRestoreRecordsResponse) String() string

type ListSlowlogRequest 

type ListSlowlogRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0
	Offset *int32 `json:"offset,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 返回结果按该关键字排序，支持start_time，duration，默认为“start_time”
	SortKey *ListSlowlogRequestSortKey `json:"sort_key,omitempty"`

	// 降序或升序（分别对应desc和asc，默认为“desc”）
	SortDir *ListSlowlogRequestSortDir `json:"sort_dir,omitempty"`

	// 查询开始时间，时间为UTC时间的Unix时间戳。如：1598803200000。
	StartTime string `json:"start_time"`

	// 查询结束时间，时间为UTC时间的Unix时间戳。如：1599494399000。
	EndTime string `json:"end_time"`
}

ListSlowlogRequest Request Object

func (ListSlowlogRequest) String 

func (o ListSlowlogRequest) String() string

type ListSlowlogRequestSortDir 

type ListSlowlogRequestSortDir struct {
	// contains filtered or unexported fields
}

func (ListSlowlogRequestSortDir) MarshalJSON 

func (c ListSlowlogRequestSortDir) MarshalJSON() ([]byte, error)

func (*ListSlowlogRequestSortDir) UnmarshalJSON 

func (c *ListSlowlogRequestSortDir) UnmarshalJSON(b []byte) error

func (ListSlowlogRequestSortDir) Value 

func (c ListSlowlogRequestSortDir) Value() string

type ListSlowlogRequestSortDirEnum 

type ListSlowlogRequestSortDirEnum struct {
	DESC ListSlowlogRequestSortDir
	ASC  ListSlowlogRequestSortDir
}

func GetListSlowlogRequestSortDirEnum 

func GetListSlowlogRequestSortDirEnum() ListSlowlogRequestSortDirEnum

type ListSlowlogRequestSortKey 

type ListSlowlogRequestSortKey struct {
	// contains filtered or unexported fields
}

func (ListSlowlogRequestSortKey) MarshalJSON 

func (c ListSlowlogRequestSortKey) MarshalJSON() ([]byte, error)

func (*ListSlowlogRequestSortKey) UnmarshalJSON 

func (c *ListSlowlogRequestSortKey) UnmarshalJSON(b []byte) error

func (ListSlowlogRequestSortKey) Value 

func (c ListSlowlogRequestSortKey) Value() string

type ListSlowlogRequestSortKeyEnum 

type ListSlowlogRequestSortKeyEnum struct {
	START_TIME ListSlowlogRequestSortKey
	DURATION   ListSlowlogRequestSortKey
}

func GetListSlowlogRequestSortKeyEnum 

func GetListSlowlogRequestSortKeyEnum() ListSlowlogRequestSortKeyEnum

type ListSlowlogResponse 

type ListSlowlogResponse struct {

	// 总数
	Count *int32 `json:"count,omitempty"`

	// 慢日志列表
	Slowlogs       *[]SlowlogItem `json:"slowlogs,omitempty"`
	HttpStatusCode int            `json:"-"`
}

ListSlowlogResponse Response Object

func (ListSlowlogResponse) String 

func (o ListSlowlogResponse) String() string

type ListStatisticsOfRunningInstancesRequest 

type ListStatisticsOfRunningInstancesRequest struct {
}

ListStatisticsOfRunningInstancesRequest Request Object

func (ListStatisticsOfRunningInstancesRequest) String 

func (o ListStatisticsOfRunningInstancesRequest) String() string

type ListStatisticsOfRunningInstancesResponse 

type ListStatisticsOfRunningInstancesResponse struct {

	// 该租户下处于“运行中”状态的实例的统计信息。
	Statistics     *[]InstanceStatistic `json:"statistics,omitempty"`
	HttpStatusCode int                  `json:"-"`
}

ListStatisticsOfRunningInstancesResponse Response Object

func (ListStatisticsOfRunningInstancesResponse) String 

func (o ListStatisticsOfRunningInstancesResponse) String() string

type ListTagsOfTenantRequest 

type ListTagsOfTenantRequest struct {
}

ListTagsOfTenantRequest Request Object

func (ListTagsOfTenantRequest) String 

func (o ListTagsOfTenantRequest) String() string

type ListTagsOfTenantResponse 

type ListTagsOfTenantResponse struct {

	// 标签列表。
	Tags           *[]Tag `json:"tags,omitempty"`
	HttpStatusCode int    `json:"-"`
}

ListTagsOfTenantResponse Response Object

func (ListTagsOfTenantResponse) String 

func (o ListTagsOfTenantResponse) String() string

type MaintainWindowsEntity 

type MaintainWindowsEntity struct {

	// 序号。
	Seq *int32 `json:"seq,omitempty"`

	// 是否为默认时间段。
	Default *bool `json:"default,omitempty"`

	// 维护时间窗开始时间
	Begin *string `json:"begin,omitempty"`

	// 维护时间窗结束时间。
	End *string `json:"end,omitempty"`
}

MaintainWindowsEntity 维护时间窗结构体

func (MaintainWindowsEntity) String 

func (o MaintainWindowsEntity) String() string

type MigrationTaskList 

type MigrationTaskList struct {

	// 迁移任务ID。
	TaskId *string `json:"task_id,omitempty"`

	// 迁移任务名称。
	TaskName *string `json:"task_name,omitempty"`

	// 迁移任务状态，这个字段的值包括：SUCCESS, FAILED, MIGRATING，TERMINATED
	Status *MigrationTaskListStatus `json:"status,omitempty"`

	// 迁移任务类型,包括备份文件导入和在线迁移两种类型。
	MigrationType *MigrationTaskListMigrationType `json:"migration_type,omitempty"`

	// 迁移方式，包括全量迁移和增量迁移两种类型。
	MigrationMethod *MigrationTaskListMigrationMethod `json:"migration_method,omitempty"`

	// 迁移机租户侧私有IP，与目的/源redis私有IP处于同VPC，可将此IP加入白名单
	EcsTenantPrivateIp *string `json:"ecs_tenant_private_ip,omitempty"`

	// 数据源，格式为ip:port或者桶名。
	DataSource *string `json:"data_source,omitempty"`

	// 源实例名称，若自建redis则为空。
	SourceInstanceName *string `json:"source_instance_name,omitempty"`

	// 源实例ID，若自建redis则为空。
	SourceInstanceId *string `json:"source_instance_id,omitempty"`

	// 目标redis地址，格式为ip:port。
	TargetInstanceAddrs *string `json:"target_instance_addrs,omitempty"`

	// 目标实例名称。
	TargetInstanceName *string `json:"target_instance_name,omitempty"`

	// 目标实例ID。
	TargetInstanceId *string `json:"target_instance_id,omitempty"`

	// 迁移任务创建时间
	CreatedAt *string `json:"created_at,omitempty"`
}

MigrationTaskList 查询迁移任务列表

func (MigrationTaskList) String 

func (o MigrationTaskList) String() string

type MigrationTaskListMigrationMethod 

type MigrationTaskListMigrationMethod struct {
	// contains filtered or unexported fields
}

func (MigrationTaskListMigrationMethod) MarshalJSON 

func (c MigrationTaskListMigrationMethod) MarshalJSON() ([]byte, error)

func (*MigrationTaskListMigrationMethod) UnmarshalJSON 

func (c *MigrationTaskListMigrationMethod) UnmarshalJSON(b []byte) error

func (MigrationTaskListMigrationMethod) Value 

func (c MigrationTaskListMigrationMethod) Value() string

type MigrationTaskListMigrationMethodEnum 

type MigrationTaskListMigrationMethodEnum struct {
	FULL_AMOUNT_MIGRATION MigrationTaskListMigrationMethod
	INCREMENTAL_MIGRATION MigrationTaskListMigrationMethod
}

func GetMigrationTaskListMigrationMethodEnum 

func GetMigrationTaskListMigrationMethodEnum() MigrationTaskListMigrationMethodEnum

type MigrationTaskListMigrationType 

type MigrationTaskListMigrationType struct {
	// contains filtered or unexported fields
}

func (MigrationTaskListMigrationType) MarshalJSON 

func (c MigrationTaskListMigrationType) MarshalJSON() ([]byte, error)

func (*MigrationTaskListMigrationType) UnmarshalJSON 

func (c *MigrationTaskListMigrationType) UnmarshalJSON(b []byte) error

func (MigrationTaskListMigrationType) Value 

func (c MigrationTaskListMigrationType) Value() string

type MigrationTaskListMigrationTypeEnum 

type MigrationTaskListMigrationTypeEnum struct {
	BACKUPFILE_IMPORT MigrationTaskListMigrationType
	ONLINE_MIGRATION  MigrationTaskListMigrationType
}

func GetMigrationTaskListMigrationTypeEnum 

func GetMigrationTaskListMigrationTypeEnum() MigrationTaskListMigrationTypeEnum

type MigrationTaskListStatus 

type MigrationTaskListStatus struct {
	// contains filtered or unexported fields
}

func (MigrationTaskListStatus) MarshalJSON 

func (c MigrationTaskListStatus) MarshalJSON() ([]byte, error)

func (*MigrationTaskListStatus) UnmarshalJSON 

func (c *MigrationTaskListStatus) UnmarshalJSON(b []byte) error

func (MigrationTaskListStatus) Value 

func (c MigrationTaskListStatus) Value() string

type MigrationTaskListStatusEnum 

type MigrationTaskListStatusEnum struct {
	SUCCESS    MigrationTaskListStatus
	FAILED     MigrationTaskListStatus
	MIGRATING  MigrationTaskListStatus
	TERMINATED MigrationTaskListStatus
}

func GetMigrationTaskListStatusEnum 

func GetMigrationTaskListStatusEnum() MigrationTaskListStatusEnum

type ModifyInstanceBody 

type ModifyInstanceBody struct {

	// 实例名称  由英文字符开头，只能由英文字母、数字、中划线和下划线组成。  创建单个实例时，名称长度为4到64位的字符串。批量创建实例时，名称长度为4到56位的字符串，且实例名称格式为“自定义名称-n”，其中n从000开始，依次递增。例如，批量创建两个实例，自定义名称为dcs_demo，则两个实例的名称为dcs_demo-000和dcs_demo-001。
	Name *string `json:"name,omitempty"`

	// 实例的描述信息 长度不超过1024的字符串。 > \\与\"在json报文中属于特殊字符，如果参数值中需要显示\\或者\"字符，请在字符前增加转义字符\\，比如\\\\或者\\\"。
	Description *string `json:"description,omitempty"`

	// 修改Redis实例的访问端口。端口范围为1~65535的任意数字。 修改后，Redis实例的所有连接将会中断，业务需要重新连接Redis的新端口。 只有Redis4.0和Redis5.0支持修改端口号，Redis3.0[和Memcached](tag:hc,hk,ocb,sbc,tm,ctc,cmc)实例不支持。
	Port *int32 `json:"port,omitempty"`

	RenameCommands *RenameCommandResp `json:"rename_commands,omitempty"`

	// '维护时间窗开始时间，为UTC时间，格式为HH:mm:ss。' - 维护时间窗开始和结束时间必须为指定的时间段，可参考[查询维护时间窗时间段](https://support.huaweicloud.com/api-dcs/ListMaintenanceWindows.html)获取。 - 开始时间必须为22:00:00、02:00:00、06:00:00、10:00:00、14:00:00和18:00:00。 - 该参数不能单独为空，若该值为空，则结束时间也为空。
	MaintainBegin *string `json:"maintain_begin,omitempty"`

	// '维护时间窗开始时间，为UTC时间，格式为HH:mm:ss。' - 维护时间窗开始和结束时间必须为指定的时间段，可参考[查询维护时间窗时间段](https://support.huaweicloud.com/api-dcs/ListMaintenanceWindows.html)获取。 - 结束时间在开始时间基础上加四个小时，即当开始时间为22:00:00时，结束时间为02:00:00。 - 该参数不能单独为空，若该值为空，则开始时间也为空。
	MaintainEnd *string `json:"maintain_end,omitempty"`

	// 安全组ID  可从虚拟私有云服务的控制台界面或者API接口查询得到。  约束：只有Redis 3.0支持
	SecurityGroupId *string `json:"security_group_id,omitempty"`

	InstanceBackupPolicy *BackupPolicy `json:"instance_backup_policy,omitempty"`
}

ModifyInstanceBody 修改实例信息

func (ModifyInstanceBody) String 

func (o ModifyInstanceBody) String() string

type ModifyInstancePasswordBody 

type ModifyInstancePasswordBody struct {

	// 旧密码
	OldPassword string `json:"old_password"`

	// 新密码
	NewPassword string `json:"new_password"`
}

func (ModifyInstancePasswordBody) String 

func (o ModifyInstancePasswordBody) String() string

type ModifyIpWhitelistBody 

type ModifyIpWhitelistBody struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 是否启用白名单（true/false）。
	EnableWhitelist bool `json:"enable_whitelist"`

	// IP白名单分组列表。
	Whitelist []Whitelist `json:"whitelist"`
}

ModifyIpWhitelistBody 设置IP白名单结构体

func (ModifyIpWhitelistBody) String 

func (o ModifyIpWhitelistBody) String() string

type ModifyRedisConfigBody 

type ModifyRedisConfigBody struct {

	// 实例配置项数组。
	RedisConfig *[]RedisConfig `json:"redis_config,omitempty"`
}

ModifyRedisConfigBody 修改配置参数请求体

func (ModifyRedisConfigBody) String 

func (o ModifyRedisConfigBody) String() string

type NodesInfoResp 

type NodesInfoResp struct {

	// 逻辑节点ID
	LogicalNodeId *string `json:"logical_node_id,omitempty"`

	// 节点名称
	Name *string `json:"name,omitempty"`

	// 节点状态，所有值如下: - Creating：创建中。 - Active：运行中。 - Inactive：故障。 - Deleting：删除中。 - AddSharding：添加分片中。
	Status *NodesInfoRespStatus `json:"status,omitempty"`

	// 可用区code
	AzCode *string `json:"az_code,omitempty"`

	// 节点角色，所有值如下: - redis-server：Redis server节点。 - redis-proxy：proxy节点。
	NodeRole *NodesInfoRespNodeRole `json:"node_role,omitempty"`

	// 节点主从角色: - master：主 - slave：从 - proxy: proxy实例节点角色为\"proxy\"
	NodeType *NodesInfoRespNodeType `json:"node_type,omitempty"`

	// 节点的IP
	NodeIp *string `json:"node_ip,omitempty"`

	// 节点的port
	NodePort *string `json:"node_port,omitempty"`

	// 节点ID
	NodeId *string `json:"node_id,omitempty"`

	// 节点权重
	PriorityWeight *int32 `json:"priority_weight,omitempty"`

	// 节点的IP是否可直接访问
	IsAccess *bool `json:"is_access,omitempty"`

	// 分片ID
	GroupId *string `json:"group_id,omitempty"`

	// 分片名称
	GroupName *string `json:"group_name,omitempty"`

	// 是否从只读域名中摘除IP
	IsRemoveIp *bool `json:"is_remove_ip,omitempty"`

	// 副本id
	ReplicationId *string `json:"replication_id,omitempty"`

	// 副本对应的监控指标维度信息。可用于调用云监控服务的查询监控数据指标相关接口 - 副本的监控维度为多维度，返回数组中包含两个维度信息。从云监控查询监控数据时，要按多维度传递指标维度参数，才能查询到监控指标值 - 第一个维度为副本父维度信息 维度名称为dcs_instance_id，维度值对应副本所在的实例ID - 第二个维度，维度名称为dcs_cluster_redis_node,维度值为副本的监控对象ID，与副本ID和节点ID不同。
	Dimensions *[]InstanceReplicationDimensionsInfo `json:"dimensions,omitempty"`
}

func (NodesInfoResp) String 

func (o NodesInfoResp) String() string

type NodesInfoRespNodeRole 

type NodesInfoRespNodeRole struct {
	// contains filtered or unexported fields
}

func (NodesInfoRespNodeRole) MarshalJSON 

func (c NodesInfoRespNodeRole) MarshalJSON() ([]byte, error)

func (*NodesInfoRespNodeRole) UnmarshalJSON 

func (c *NodesInfoRespNodeRole) UnmarshalJSON(b []byte) error

func (NodesInfoRespNodeRole) Value 

func (c NodesInfoRespNodeRole) Value() string

type NodesInfoRespNodeRoleEnum 

type NodesInfoRespNodeRoleEnum struct {
	REDIS_SERVER NodesInfoRespNodeRole
	REDIS_PROXY  NodesInfoRespNodeRole
}

func GetNodesInfoRespNodeRoleEnum 

func GetNodesInfoRespNodeRoleEnum() NodesInfoRespNodeRoleEnum

type NodesInfoRespNodeType 

type NodesInfoRespNodeType struct {
	// contains filtered or unexported fields
}

func (NodesInfoRespNodeType) MarshalJSON 

func (c NodesInfoRespNodeType) MarshalJSON() ([]byte, error)

func (*NodesInfoRespNodeType) UnmarshalJSON 

func (c *NodesInfoRespNodeType) UnmarshalJSON(b []byte) error

func (NodesInfoRespNodeType) Value 

func (c NodesInfoRespNodeType) Value() string

type NodesInfoRespNodeTypeEnum 

type NodesInfoRespNodeTypeEnum struct {
	MASTER NodesInfoRespNodeType
	SLAVE  NodesInfoRespNodeType
	PROXY  NodesInfoRespNodeType
}

func GetNodesInfoRespNodeTypeEnum 

func GetNodesInfoRespNodeTypeEnum() NodesInfoRespNodeTypeEnum

type NodesInfoRespStatus 

type NodesInfoRespStatus struct {
	// contains filtered or unexported fields
}

func (NodesInfoRespStatus) MarshalJSON 

func (c NodesInfoRespStatus) MarshalJSON() ([]byte, error)

func (*NodesInfoRespStatus) UnmarshalJSON 

func (c *NodesInfoRespStatus) UnmarshalJSON(b []byte) error

func (NodesInfoRespStatus) Value 

func (c NodesInfoRespStatus) Value() string

type NodesInfoRespStatusEnum 

type NodesInfoRespStatusEnum struct {
	CREATING     NodesInfoRespStatus
	ACTIVE       NodesInfoRespStatus
	INACTIVE     NodesInfoRespStatus
	DELETING     NodesInfoRespStatus
	ADD_SHARDING NodesInfoRespStatus
}

func GetNodesInfoRespStatusEnum 

func GetNodesInfoRespStatusEnum() NodesInfoRespStatusEnum

type PriorityBody 

type PriorityBody struct {

	// 副本优先级，取值范围是0到100，0为默认禁止倒换。
	SlavePriorityWeight int32 `json:"slave_priority_weight"`
}

func (PriorityBody) String 

func (o PriorityBody) String() string

type Proxy2NodeMonitoredObject 

type Proxy2NodeMonitoredObject struct {

	// 测量对象ID，即节点的ID。
	DcsInstanceId *string `json:"dcs_instance_id,omitempty"`

	// 测量对象名称，即节点IP。
	Name *string `json:"name,omitempty"`

	// 维度dcs_cluster_proxy2_node 的测量对象的ID。
	DcsClusterProxy2Node *string `json:"dcs_cluster_proxy2_node,omitempty"`

	// 测量对象状态，即节点状态。
	Status *string `json:"status,omitempty"`
}

Proxy2NodeMonitoredObject Redis 4.0 和 5.0 proxy集群中proxy节点监控对象结构

func (Proxy2NodeMonitoredObject) String 

func (o Proxy2NodeMonitoredObject) String() string

type ProxyNodeMonitoredObject 

type ProxyNodeMonitoredObject struct {

	// 测量对象ID，即节点的ID。
	DcsInstanceId *string `json:"dcs_instance_id,omitempty"`

	// 测量对象名称，即节点IP。
	Name *string `json:"name,omitempty"`

	// 维度dcs_cluster_proxy_node 的测量对象的ID。
	DcsClusterProxyNode *string `json:"dcs_cluster_proxy_node,omitempty"`

	// 测量对象状态，即节点状态。
	Status *string `json:"status,omitempty"`
}

ProxyNodeMonitoredObject Redis 3.0 proxy集群中proxy节点监控对象结构

func (ProxyNodeMonitoredObject) String 

func (o ProxyNodeMonitoredObject) String() string

type QueryRedisConfig 

type QueryRedisConfig struct {

	// 配置参数值。
	ParamValue *string `json:"param_value,omitempty"`

	// 配置参数的值类型。
	ValueType *string `json:"value_type,omitempty"`

	// 配置参数的取值范围。
	ValueRange *string `json:"value_range,omitempty"`

	// 配置项的描述。
	Description *string `json:"description,omitempty"`

	// 配置参数的默认值。
	DefaultValue *string `json:"default_value,omitempty"`

	// 配置参数名称。
	ParamName *string `json:"param_name,omitempty"`

	// 配置参数ID。
	ParamId *string `json:"param_id,omitempty"`
}

QueryRedisConfig 实例配置项

func (QueryRedisConfig) String 

func (o QueryRedisConfig) String() string

type QueryTenantQuotaRespQuotas 

type QueryTenantQuotaRespQuotas struct {

	// 配额列表。
	Resources *[]Resources `json:"resources,omitempty"`
}

QueryTenantQuotaRespQuotas 配额信息。

func (QueryTenantQuotaRespQuotas) String 

func (o QueryTenantQuotaRespQuotas) String() string

type RecordsResponse 

type RecordsResponse struct {

	// 大key分析记录ID
	Id *string `json:"id,omitempty"`

	// 分析任务状态
	Status *RecordsResponseStatus `json:"status,omitempty"`

	// 分析方式
	ScanType *RecordsResponseScanType `json:"scan_type,omitempty"`

	// 分析任务创建时间,格式为：\"2020-06-15T02:21:18.669Z\"
	CreatedAt *string `json:"created_at,omitempty"`

	// 分析任务开始时间,格式为：\"2020-06-15T02:21:18.669Z\"
	StartedAt *string `json:"started_at,omitempty"`

	// 分析任务结束时间,格式为：\"2020-06-15T02:21:18.669Z\"
	FinishedAt *string `json:"finished_at,omitempty"`
}

RecordsResponse 单个大key分析历史记录

func (RecordsResponse) String 

func (o RecordsResponse) String() string

type RecordsResponseScanType 

type RecordsResponseScanType struct {
	// contains filtered or unexported fields
}

func (RecordsResponseScanType) MarshalJSON 

func (c RecordsResponseScanType) MarshalJSON() ([]byte, error)

func (*RecordsResponseScanType) UnmarshalJSON 

func (c *RecordsResponseScanType) UnmarshalJSON(b []byte) error

func (RecordsResponseScanType) Value 

func (c RecordsResponseScanType) Value() string

type RecordsResponseScanTypeEnum 

type RecordsResponseScanTypeEnum struct {
	MANUAL RecordsResponseScanType
	AUTO   RecordsResponseScanType
}

func GetRecordsResponseScanTypeEnum 

func GetRecordsResponseScanTypeEnum() RecordsResponseScanTypeEnum

type RecordsResponseStatus 

type RecordsResponseStatus struct {
	// contains filtered or unexported fields
}

func (RecordsResponseStatus) MarshalJSON 

func (c RecordsResponseStatus) MarshalJSON() ([]byte, error)

func (*RecordsResponseStatus) UnmarshalJSON 

func (c *RecordsResponseStatus) UnmarshalJSON(b []byte) error

func (RecordsResponseStatus) Value 

func (c RecordsResponseStatus) Value() string

type RecordsResponseStatusEnum 

type RecordsResponseStatusEnum struct {
	WAITING RecordsResponseStatus
	RUNNING RecordsResponseStatus
	SUCCESS RecordsResponseStatus
	FAILED  RecordsResponseStatus
}

func GetRecordsResponseStatusEnum 

func GetRecordsResponseStatusEnum() RecordsResponseStatusEnum

type RedisConfig 

type RedisConfig struct {

	// 实例配置项的值。
	ParamValue string `json:"param_value"`

	// 实例配置项名。
	ParamName string `json:"param_name"`

	// 实例配置项ID。
	ParamId string `json:"param_id"`
}

func (RedisConfig) String 

func (o RedisConfig) String() string

type RenameCommandResp 

type RenameCommandResp struct {

	// 命令command
	Command *string `json:"command,omitempty"`

	// 命令flushall
	Flushall *string `json:"flushall,omitempty"`

	// 命令flushdb
	Flushdb *string `json:"flushdb,omitempty"`

	// 命令hgetall
	Hgetall *string `json:"hgetall,omitempty"`

	// 命令keys
	Keys *string `json:"keys,omitempty"`
}

func (RenameCommandResp) String 

func (o RenameCommandResp) String() string

type ResetInstancePasswordBody 

type ResetInstancePasswordBody struct {

	// 重置的新密码
	NewPassword *string `json:"new_password,omitempty"`

	// 是否重置为免密码访问缓存实例
	NoPasswordAccess *bool `json:"no_password_access,omitempty"`
}

func (ResetInstancePasswordBody) String 

func (o ResetInstancePasswordBody) String() string

type ResetPasswordRequest 

type ResetPasswordRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *ResetInstancePasswordBody `json:"body,omitempty"`
}

ResetPasswordRequest Request Object

func (ResetPasswordRequest) String 

func (o ResetPasswordRequest) String() string

type ResetPasswordResponse 

type ResetPasswordResponse struct {

	// 密码验证剩余次数
	RetryTimesLeft *string `json:"retry_times_left,omitempty"`

	// 锁定时间
	LockTime *string `json:"lock_time,omitempty"`

	// 锁定剩余时间
	LockTimeLeft   *string `json:"lock_time_left,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ResetPasswordResponse Response Object

func (ResetPasswordResponse) String 

func (o ResetPasswordResponse) String() string

type ResizeInstanceBody 

type ResizeInstanceBody struct {

	// 产品规格编码。具体查询方法如下：  - 方法一：查询产品介绍中的[实例规格](https://support.huaweicloud.com/productdesc-dcs/dcs-pd-0522002.html) - 方法二：登录分布式缓存的控制台界面，点击购买缓存实例，查找对应的实例规格名称 - 方法三：调用[查询产品规格](https://support.huaweicloud.com/api-dcs/ListFlavors.html)接口查询。
	SpecCode string `json:"spec_code"`

	// 新的缓存实例规格，单位：GB。 Redis4.0和Redis5.0：单机和主备类型实例取值：0.125、0.25、0.5、1、2、4、8、16、32、64。Cluster集群实例规格支持24、32、48、64、96、128、192、256、384、512、768、1024。 Memcached：单机和主备类型实例取值：2、4、8、16、32、64。
	NewCapacity int32 `json:"new_capacity"`

	BssParam *BssParamEntity `json:"bss_param,omitempty"`

	// 需要保留的节点ip。cluster集群缩容时需要填写，不填写时系统将随机删除多余的分片
	ReservedIp *[]string `json:"reserved_ip,omitempty"`

	// 变更类型，Redis 4.0或者5.0主备实例进行副本数变更时必选。 - createReplication: 添加副本 - deleteReplication: 删除副本
	ChangeType *ResizeInstanceBodyChangeType `json:"change_type,omitempty"`

	// Redis 4.0或者5.0主备实例进行添加副本时必选，指定每个副本所在的可用区Code，使用前需要先确认该可用区资源是否售罄。  具体查询方法，请参考[查询可用区信息](https://support.huaweicloud.com/api-dcs/ListAvailableZones.html)
	AvailableZones *[]string `json:"available_zones,omitempty"`

	// Redis 4.0或者5.0主备实例进行删除副本时必选，指定需要删除的节点ID，目前仅支持一次删除一个副本。  节点ID查询方法，请参考[查询分片信息](https://support.huaweicloud.com/api-dcs/ListGroupReplicationInfo.html)
	NodeList *[]string `json:"node_list,omitempty"`

	// 是否立即变更。默认值为true。 - true: 立即变更 - false: 可维护时间窗内进行变更
	ExecuteImmediately *bool `json:"execute_immediately,omitempty"`
}

func (ResizeInstanceBody) String 

func (o ResizeInstanceBody) String() string

type ResizeInstanceBodyChangeType 

type ResizeInstanceBodyChangeType struct {
	// contains filtered or unexported fields
}

func (ResizeInstanceBodyChangeType) MarshalJSON 

func (c ResizeInstanceBodyChangeType) MarshalJSON() ([]byte, error)

func (*ResizeInstanceBodyChangeType) UnmarshalJSON 

func (c *ResizeInstanceBodyChangeType) UnmarshalJSON(b []byte) error

func (ResizeInstanceBodyChangeType) Value 

func (c ResizeInstanceBodyChangeType) Value() string

type ResizeInstanceBodyChangeTypeEnum 

type ResizeInstanceBodyChangeTypeEnum struct {
	CREATE_REPLICATION ResizeInstanceBodyChangeType
	DELETE_REPLICATION ResizeInstanceBodyChangeType
}

func GetResizeInstanceBodyChangeTypeEnum 

func GetResizeInstanceBodyChangeTypeEnum() ResizeInstanceBodyChangeTypeEnum

type ResizeInstanceRequest 

type ResizeInstanceRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *ResizeInstanceBody `json:"body,omitempty"`
}

ResizeInstanceRequest Request Object

func (ResizeInstanceRequest) String 

func (o ResizeInstanceRequest) String() string

type ResizeInstanceResponse 

type ResizeInstanceResponse struct {
	HttpStatusCode int `json:"-"`
}

ResizeInstanceResponse Response Object

func (ResizeInstanceResponse) String 

func (o ResizeInstanceResponse) String() string

type ResourceTag 

type ResourceTag struct {

	// 标签键 - 不能为空。 - 对于同一资源键值唯一。 - 长度不超过36个字符。 - 标签的键必须唯一且输入不能为空。
	Key string `json:"key"`

	// 标签值 - action为create时必选。action为delete时非必选。 - 长度不超过43个字符。
	Value *string `json:"value,omitempty"`
}

func (ResourceTag) String 

func (o ResourceTag) String() string

type Resources 

type Resources struct {

	// 资源的计数单位。 - 当type为instance时，无单位。 - 当type为ram时，单位为GB。
	Unit *string `json:"unit,omitempty"`

	// - 当type为instance时，表示可申请实例配额的最小值。 - 当type为ram时，表示可申请内存配额的最小值。
	Min *int32 `json:"min,omitempty"`

	// - 当type为instance时，表示可申请实例配额的最大值。 - 当type为ram时，表示可申请内存配额的最大值。
	Max *int32 `json:"max,omitempty"`

	// 可以创建的实例最大数和总内存的配额限制。
	Quota *int32 `json:"quota,omitempty"`

	// 已创建的实例个数和已使用的内存配额。
	Used *int32 `json:"used,omitempty"`

	// 支持instance、ram两种。 - instance表示实例配额。 - ram表示内存配额。
	Type *string `json:"type,omitempty"`
}

func (Resources) String 

func (o Resources) String() string

type RestartOrFlushInstancesRequest 

type RestartOrFlushInstancesRequest struct {
	Body *ChangeInstanceStatusBody `json:"body,omitempty"`
}

RestartOrFlushInstancesRequest Request Object

func (RestartOrFlushInstancesRequest) String 

func (o RestartOrFlushInstancesRequest) String() string

type RestartOrFlushInstancesResponse 

type RestartOrFlushInstancesResponse struct {

	// 删除/重启/清空实例的结果。
	Results        *[]BatchOpsResult `json:"results,omitempty"`
	HttpStatusCode int               `json:"-"`
}

RestartOrFlushInstancesResponse Response Object

func (RestartOrFlushInstancesResponse) String 

func (o RestartOrFlushInstancesResponse) String() string

type RestoreInstanceBody 

type RestoreInstanceBody struct {

	// 备份记录ID。
	BackupId string `json:"backup_id"`

	// 恢复缓存实例的备注信息。
	Remark *string `json:"remark,omitempty"`
}

func (RestoreInstanceBody) String 

func (o RestoreInstanceBody) String() string

type RestoreInstanceRequest 

type RestoreInstanceRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *RestoreInstanceBody `json:"body,omitempty"`
}

RestoreInstanceRequest Request Object

func (RestoreInstanceRequest) String 

func (o RestoreInstanceRequest) String() string

type RestoreInstanceResponse 

type RestoreInstanceResponse struct {

	// 恢复记录ID。
	RestoreId      *string `json:"restore_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

RestoreInstanceResponse Response Object

func (RestoreInstanceResponse) String 

func (o RestoreInstanceResponse) String() string

type RunlogItem 

type RunlogItem struct {

	// 日志的唯一标识
	Id *string `json:"id,omitempty"`

	// 运行日志文件名
	FileName *string `json:"file_name,omitempty"`

	// 分片名称
	GroupName *string `json:"group_name,omitempty"`

	// 采集运行日志所在副本的IP
	ReplicationIp *string `json:"replication_ip,omitempty"`

	// 获取运行日志状态
	Status *string `json:"status,omitempty"`

	// 运行日志采集的日期，格式为\"yyyy-MM-dd\"
	Time *string `json:"time,omitempty"`

	// 日志文件的ID
	BackupId *string `json:"backup_id,omitempty"`
}

RunlogItem 运行日志单个条目

func (RunlogItem) String 

func (o RunlogItem) String() string

type SetOnlineMigrationTaskBody 

type SetOnlineMigrationTaskBody struct {

	// 迁移方式，包括全量迁移和增量迁移两种类型。 - 全量迁移：该模式为Redis的一次性迁移，适用于可中断业务的迁移场景。   全量迁移过程中，如果源Redis有数据更新，这部分更新数据不会被迁移到目标Redis。 - 增量迁移：该模式为Redis的持续性迁移，适用于对业务中断敏感的迁移场景。   增量迁移阶段通过解析日志等技术， 持续保持源Redis和目标端Redis的数据一致。 取值范围： - full_amount_migration：表示全量迁移。 - incremental_migration：表示增量迁移。
	MigrationMethod SetOnlineMigrationTaskBodyMigrationMethod `json:"migration_method"`

	// 自动重连，根据参数决定是否自动重连。 自动重连模式在遇到网络等异常情况时，会无限自动重试。 自动重连模式在无法进行增量同步时，会触发全量同步，增加带宽占用，请谨慎选择。 取值范围： - auto：自动重连。 - manual：手动重连。
	ResumeMode SetOnlineMigrationTaskBodyResumeMode `json:"resume_mode"`

	// 带宽限制，当迁移方式为增量迁移时，为保证业务正常运行，您可以启用带宽限制功能，当数据同步速度达到带宽限制时，将限制同步速度的继续增长。 -限制为MB/s -取值范围：1-10,241(大于0小于10,241的整数)
	BandwidthLimitMb *string `json:"bandwidth_limit_mb,omitempty"`

	SourceInstance *ConfigMigrationInstanceBody `json:"source_instance"`

	TargetInstance *ConfigMigrationInstanceBody `json:"target_instance"`
}

SetOnlineMigrationTaskBody 配置在线数据迁移任务结构体

func (SetOnlineMigrationTaskBody) String 

func (o SetOnlineMigrationTaskBody) String() string

type SetOnlineMigrationTaskBodyMigrationMethod 

type SetOnlineMigrationTaskBodyMigrationMethod struct {
	// contains filtered or unexported fields
}

func (SetOnlineMigrationTaskBodyMigrationMethod) MarshalJSON 

func (c SetOnlineMigrationTaskBodyMigrationMethod) MarshalJSON() ([]byte, error)

func (*SetOnlineMigrationTaskBodyMigrationMethod) UnmarshalJSON 

func (c *SetOnlineMigrationTaskBodyMigrationMethod) UnmarshalJSON(b []byte) error

func (SetOnlineMigrationTaskBodyMigrationMethod) Value 

func (c SetOnlineMigrationTaskBodyMigrationMethod) Value() string

type SetOnlineMigrationTaskBodyMigrationMethodEnum 

type SetOnlineMigrationTaskBodyMigrationMethodEnum struct {
	FULL_AMOUNT_MIGRATION SetOnlineMigrationTaskBodyMigrationMethod
	INCREMENTAL_MIGRATION SetOnlineMigrationTaskBodyMigrationMethod
}

func GetSetOnlineMigrationTaskBodyMigrationMethodEnum 

func GetSetOnlineMigrationTaskBodyMigrationMethodEnum() SetOnlineMigrationTaskBodyMigrationMethodEnum

type SetOnlineMigrationTaskBodyResumeMode 

type SetOnlineMigrationTaskBodyResumeMode struct {
	// contains filtered or unexported fields
}

func (SetOnlineMigrationTaskBodyResumeMode) MarshalJSON 

func (c SetOnlineMigrationTaskBodyResumeMode) MarshalJSON() ([]byte, error)

func (*SetOnlineMigrationTaskBodyResumeMode) UnmarshalJSON 

func (c *SetOnlineMigrationTaskBodyResumeMode) UnmarshalJSON(b []byte) error

func (SetOnlineMigrationTaskBodyResumeMode) Value 

func (c SetOnlineMigrationTaskBodyResumeMode) Value() string

type SetOnlineMigrationTaskBodyResumeModeEnum 

type SetOnlineMigrationTaskBodyResumeModeEnum struct {
	AUTO   SetOnlineMigrationTaskBodyResumeMode
	MANUAL SetOnlineMigrationTaskBodyResumeMode
}

func GetSetOnlineMigrationTaskBodyResumeModeEnum 

func GetSetOnlineMigrationTaskBodyResumeModeEnum() SetOnlineMigrationTaskBodyResumeModeEnum

type SetOnlineMigrationTaskRequest 

type SetOnlineMigrationTaskRequest struct {

	// 在线迁移任务ID。
	TaskId string `json:"task_id"`

	Body *SetOnlineMigrationTaskBody `json:"body,omitempty"`
}

SetOnlineMigrationTaskRequest Request Object

func (SetOnlineMigrationTaskRequest) String 

func (o SetOnlineMigrationTaskRequest) String() string

type SetOnlineMigrationTaskResponse 

type SetOnlineMigrationTaskResponse struct {

	// 迁移任务ID。
	Id *string `json:"id,omitempty"`

	// 迁移任务名称。
	Name *string `json:"name,omitempty"`

	// 迁移任务状态，这个字段的值包括：SUCCESS, FAILED, MIGRATING，TERMINATED
	Status         *SetOnlineMigrationTaskResponseStatus `json:"status,omitempty"`
	HttpStatusCode int                                   `json:"-"`
}

SetOnlineMigrationTaskResponse Response Object

func (SetOnlineMigrationTaskResponse) String 

func (o SetOnlineMigrationTaskResponse) String() string

type SetOnlineMigrationTaskResponseStatus 

type SetOnlineMigrationTaskResponseStatus struct {
	// contains filtered or unexported fields
}

func (SetOnlineMigrationTaskResponseStatus) MarshalJSON 

func (c SetOnlineMigrationTaskResponseStatus) MarshalJSON() ([]byte, error)

func (*SetOnlineMigrationTaskResponseStatus) UnmarshalJSON 

func (c *SetOnlineMigrationTaskResponseStatus) UnmarshalJSON(b []byte) error

func (SetOnlineMigrationTaskResponseStatus) Value 

func (c SetOnlineMigrationTaskResponseStatus) Value() string

type SetOnlineMigrationTaskResponseStatusEnum 

type SetOnlineMigrationTaskResponseStatusEnum struct {
	SUCCESS    SetOnlineMigrationTaskResponseStatus
	FAILED     SetOnlineMigrationTaskResponseStatus
	MIGRATING  SetOnlineMigrationTaskResponseStatus
	TERMINATED SetOnlineMigrationTaskResponseStatus
}

func GetSetOnlineMigrationTaskResponseStatusEnum 

func GetSetOnlineMigrationTaskResponseStatusEnum() SetOnlineMigrationTaskResponseStatusEnum

type ShowBigkeyAutoscanConfigRequest 

type ShowBigkeyAutoscanConfigRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

ShowBigkeyAutoscanConfigRequest Request Object

func (ShowBigkeyAutoscanConfigRequest) String 

func (o ShowBigkeyAutoscanConfigRequest) String() string

type ShowBigkeyAutoscanConfigResponse 

type ShowBigkeyAutoscanConfigResponse struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 是否开启自动分析
	EnableAutoScan *bool `json:"enable_auto_scan,omitempty"`

	// 每日分析时间，时间格式为21:00
	ScheduleAt *[]string `json:"schedule_at,omitempty"`

	// 配置更新时间，时间格式为2020-06-15T02:21:18.669Z
	UpdatedAt      *string `json:"updated_at,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowBigkeyAutoscanConfigResponse Response Object

func (ShowBigkeyAutoscanConfigResponse) String 

func (o ShowBigkeyAutoscanConfigResponse) String() string

type ShowBigkeyScanTaskDetailsRequest 

type ShowBigkeyScanTaskDetailsRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 大key分析任务ID。
	BigkeyId string `json:"bigkey_id"`
}

ShowBigkeyScanTaskDetailsRequest Request Object

func (ShowBigkeyScanTaskDetailsRequest) String 

func (o ShowBigkeyScanTaskDetailsRequest) String() string

type ShowBigkeyScanTaskDetailsResponse 

type ShowBigkeyScanTaskDetailsResponse struct {

	// 大key分析记录ID
	Id *string `json:"id,omitempty"`

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 分析任务状态
	Status *ShowBigkeyScanTaskDetailsResponseStatus `json:"status,omitempty"`

	// 分析方式
	ScanType *ShowBigkeyScanTaskDetailsResponseScanType `json:"scan_type,omitempty"`

	// 分析任务创建时间,格式为：\"2020-06-15T02:21:18.669Z\"
	CreatedAt *string `json:"created_at,omitempty"`

	// 分析任务开始时间,格式为：\"2020-06-15T02:21:18.669Z\"
	StartedAt *string `json:"started_at,omitempty"`

	// 分析任务结束时间,格式为：\"2020-06-15T02:21:18.669Z\"
	FinishedAt *string `json:"finished_at,omitempty"`

	// 大key的数量
	Num *int32 `json:"num,omitempty"`

	// 大key记录
	Keys           *[]BigkeysBody `json:"keys,omitempty"`
	HttpStatusCode int            `json:"-"`
}

ShowBigkeyScanTaskDetailsResponse Response Object

func (ShowBigkeyScanTaskDetailsResponse) String 

func (o ShowBigkeyScanTaskDetailsResponse) String() string

type ShowBigkeyScanTaskDetailsResponseScanType 

type ShowBigkeyScanTaskDetailsResponseScanType struct {
	// contains filtered or unexported fields
}

func (ShowBigkeyScanTaskDetailsResponseScanType) MarshalJSON 

func (c ShowBigkeyScanTaskDetailsResponseScanType) MarshalJSON() ([]byte, error)

func (*ShowBigkeyScanTaskDetailsResponseScanType) UnmarshalJSON 

func (c *ShowBigkeyScanTaskDetailsResponseScanType) UnmarshalJSON(b []byte) error

func (ShowBigkeyScanTaskDetailsResponseScanType) Value 

func (c ShowBigkeyScanTaskDetailsResponseScanType) Value() string

type ShowBigkeyScanTaskDetailsResponseScanTypeEnum 

type ShowBigkeyScanTaskDetailsResponseScanTypeEnum struct {
	MANUAL ShowBigkeyScanTaskDetailsResponseScanType
	AUTO   ShowBigkeyScanTaskDetailsResponseScanType
}

func GetShowBigkeyScanTaskDetailsResponseScanTypeEnum 

func GetShowBigkeyScanTaskDetailsResponseScanTypeEnum() ShowBigkeyScanTaskDetailsResponseScanTypeEnum

type ShowBigkeyScanTaskDetailsResponseStatus 

type ShowBigkeyScanTaskDetailsResponseStatus struct {
	// contains filtered or unexported fields
}

func (ShowBigkeyScanTaskDetailsResponseStatus) MarshalJSON 

func (c ShowBigkeyScanTaskDetailsResponseStatus) MarshalJSON() ([]byte, error)

func (*ShowBigkeyScanTaskDetailsResponseStatus) UnmarshalJSON 

func (c *ShowBigkeyScanTaskDetailsResponseStatus) UnmarshalJSON(b []byte) error

func (ShowBigkeyScanTaskDetailsResponseStatus) Value 

func (c ShowBigkeyScanTaskDetailsResponseStatus) Value() string

type ShowBigkeyScanTaskDetailsResponseStatusEnum 

type ShowBigkeyScanTaskDetailsResponseStatusEnum struct {
	WAITING ShowBigkeyScanTaskDetailsResponseStatus
	RUNNING ShowBigkeyScanTaskDetailsResponseStatus
	SUCCESS ShowBigkeyScanTaskDetailsResponseStatus
	FAILED  ShowBigkeyScanTaskDetailsResponseStatus
}

func GetShowBigkeyScanTaskDetailsResponseStatusEnum 

func GetShowBigkeyScanTaskDetailsResponseStatusEnum() ShowBigkeyScanTaskDetailsResponseStatusEnum

type ShowDiagnosisTaskDetailsRequest 

type ShowDiagnosisTaskDetailsRequest struct {

	// 诊断报告ID
	ReportId string `json:"report_id"`
}

ShowDiagnosisTaskDetailsRequest Request Object

func (ShowDiagnosisTaskDetailsRequest) String 

func (o ShowDiagnosisTaskDetailsRequest) String() string

type ShowDiagnosisTaskDetailsResponse 

type ShowDiagnosisTaskDetailsResponse struct {

	// 诊断结果为异常的诊断项总数
	AbnormalItemSum *int32 `json:"abnormal_item_sum,omitempty"`

	// 诊断失败的诊断项总数
	FailedItemSum *int32 `json:"failed_item_sum,omitempty"`

	// 节点诊断报告列表
	DiagnosisNodeReportList *[]DiagnosisNodeReport `json:"diagnosis_node_report_list,omitempty"`
	HttpStatusCode          int                    `json:"-"`
}

ShowDiagnosisTaskDetailsResponse Response Object

func (ShowDiagnosisTaskDetailsResponse) String 

func (o ShowDiagnosisTaskDetailsResponse) String() string

type ShowHotkeyAutoscanConfigRequest 

type ShowHotkeyAutoscanConfigRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

ShowHotkeyAutoscanConfigRequest Request Object

func (ShowHotkeyAutoscanConfigRequest) String 

func (o ShowHotkeyAutoscanConfigRequest) String() string

type ShowHotkeyAutoscanConfigResponse 

type ShowHotkeyAutoscanConfigResponse struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 是否开启自动分析
	EnableAutoScan *bool `json:"enable_auto_scan,omitempty"`

	// 每日分析时间，时间格式为21:00
	ScheduleAt *[]string `json:"schedule_at,omitempty"`

	// 配置更新时间，时间格式为2020-06-15T02:21:18.669Z
	UpdatedAt      *string `json:"updated_at,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowHotkeyAutoscanConfigResponse Response Object

func (ShowHotkeyAutoscanConfigResponse) String 

func (o ShowHotkeyAutoscanConfigResponse) String() string

type ShowHotkeyTaskDetailsRequest 

type ShowHotkeyTaskDetailsRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 热key分析任务ID。
	HotkeyId string `json:"hotkey_id"`
}

ShowHotkeyTaskDetailsRequest Request Object

func (ShowHotkeyTaskDetailsRequest) String 

func (o ShowHotkeyTaskDetailsRequest) String() string

type ShowHotkeyTaskDetailsResponse 

type ShowHotkeyTaskDetailsResponse struct {

	// 热key分析记录ID
	Id *string `json:"id,omitempty"`

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 分析任务状态
	Status *ShowHotkeyTaskDetailsResponseStatus `json:"status,omitempty"`

	// 分析方式
	ScanType *ShowHotkeyTaskDetailsResponseScanType `json:"scan_type,omitempty"`

	// 分析任务创建时间,格式为：\"2020-06-15T02:21:18.669Z\"
	CreatedAt *string `json:"created_at,omitempty"`

	// 分析任务开始时间,格式为：\"2020-06-15T02:21:18.669Z\"
	StartedAt *string `json:"started_at,omitempty"`

	// 分析任务结束时间,格式为：\"2020-06-15T02:21:18.669Z\"
	FinishedAt *string `json:"finished_at,omitempty"`

	// 热key的数量
	Num *int32 `json:"num,omitempty"`

	// 热key记录
	Keys           *[]HotkeysBody `json:"keys,omitempty"`
	HttpStatusCode int            `json:"-"`
}

ShowHotkeyTaskDetailsResponse Response Object

func (ShowHotkeyTaskDetailsResponse) String 

func (o ShowHotkeyTaskDetailsResponse) String() string

type ShowHotkeyTaskDetailsResponseScanType 

type ShowHotkeyTaskDetailsResponseScanType struct {
	// contains filtered or unexported fields
}

func (ShowHotkeyTaskDetailsResponseScanType) MarshalJSON 

func (c ShowHotkeyTaskDetailsResponseScanType) MarshalJSON() ([]byte, error)

func (*ShowHotkeyTaskDetailsResponseScanType) UnmarshalJSON 

func (c *ShowHotkeyTaskDetailsResponseScanType) UnmarshalJSON(b []byte) error

func (ShowHotkeyTaskDetailsResponseScanType) Value 

func (c ShowHotkeyTaskDetailsResponseScanType) Value() string

type ShowHotkeyTaskDetailsResponseScanTypeEnum 

type ShowHotkeyTaskDetailsResponseScanTypeEnum struct {
	MANUAL ShowHotkeyTaskDetailsResponseScanType
	AUTO   ShowHotkeyTaskDetailsResponseScanType
}

func GetShowHotkeyTaskDetailsResponseScanTypeEnum 

func GetShowHotkeyTaskDetailsResponseScanTypeEnum() ShowHotkeyTaskDetailsResponseScanTypeEnum

type ShowHotkeyTaskDetailsResponseStatus 

type ShowHotkeyTaskDetailsResponseStatus struct {
	// contains filtered or unexported fields
}

func (ShowHotkeyTaskDetailsResponseStatus) MarshalJSON 

func (c ShowHotkeyTaskDetailsResponseStatus) MarshalJSON() ([]byte, error)

func (*ShowHotkeyTaskDetailsResponseStatus) UnmarshalJSON 

func (c *ShowHotkeyTaskDetailsResponseStatus) UnmarshalJSON(b []byte) error

func (ShowHotkeyTaskDetailsResponseStatus) Value 

func (c ShowHotkeyTaskDetailsResponseStatus) Value() string

type ShowHotkeyTaskDetailsResponseStatusEnum 

type ShowHotkeyTaskDetailsResponseStatusEnum struct {
	WAITING ShowHotkeyTaskDetailsResponseStatus
	RUNNING ShowHotkeyTaskDetailsResponseStatus
	SUCCESS ShowHotkeyTaskDetailsResponseStatus
	FAILED  ShowHotkeyTaskDetailsResponseStatus
}

func GetShowHotkeyTaskDetailsResponseStatusEnum 

func GetShowHotkeyTaskDetailsResponseStatusEnum() ShowHotkeyTaskDetailsResponseStatusEnum

type ShowInstanceRequest 

type ShowInstanceRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

ShowInstanceRequest Request Object

func (ShowInstanceRequest) String 

func (o ShowInstanceRequest) String() string

type ShowInstanceResponse 

type ShowInstanceResponse struct {

	// VPC的名称。
	VpcName *string `json:"vpc_name,omitempty"`

	// 付费模式，0表示按需计费，1表示包年/包月计费。
	ChargingMode *int32 `json:"charging_mode,omitempty"`

	// VPC ID
	VpcId *string `json:"vpc_id,omitempty"`

	// 用户名。
	UserName *string `json:"user_name,omitempty"`

	// 完成创建时间。格式为：2017-03-31T12:24:46.297Z
	CreatedAt *string `json:"created_at,omitempty"`

	// 实例描述。
	Description *string `json:"description,omitempty"`

	// 安全组ID。
	SecurityGroupId *string `json:"security_group_id,omitempty"`

	// 租户安全组名称。
	SecurityGroupName *string `json:"security_group_name,omitempty"`

	// 总内存，单位：MB。
	MaxMemory *int32 `json:"max_memory,omitempty"`

	// 已使用的内存，单位：MB。
	UsedMemory *int32 `json:"used_memory,omitempty"`

	// 缓存实例的容量（G Byte）。
	Capacity *int32 `json:"capacity,omitempty"`

	// 单机小规格的缓存容量。
	CapacityMinor *string `json:"capacity_minor,omitempty"`

	// 维护时间窗开始时间，为UTC时间，格式为HH:mm:ss
	MaintainBegin *string `json:"maintain_begin,omitempty"`

	// 维护时间窗结束时间，为UTC时间，格式为HH:mm:ss
	MaintainEnd *string `json:"maintain_end,omitempty"`

	// 缓存实例的引擎类型。
	Engine *string `json:"engine,omitempty"`

	// 是否允许免密码访问缓存实例。 - true：该实例无需密码即可访问。 - false：该实例必须通过密码认证才能访问。
	NoPasswordAccess *string `json:"no_password_access,omitempty"`

	// 连接缓存实例的IP地址。如果是集群实例，返回多个IP地址，使用逗号分隔。如：192.168.0.1，192.168.0.2。
	Ip *string `json:"ip,omitempty"`

	InstanceBackupPolicy *InstanceBackupPolicy `json:"instance_backup_policy,omitempty"`

	// 实例所在的可用区。返回“可用区Code”
	AzCodes *[]string `json:"az_codes,omitempty"`

	// 通过密码认证访问缓存实例的认证用户名。
	AccessUser *string `json:"access_user,omitempty"`

	// 实例ID。
	InstanceId *string `json:"instance_id,omitempty"`

	// 缓存的端口。
	Port *int32 `json:"port,omitempty"`

	// 用户id。
	UserId *string `json:"user_id,omitempty"`

	// 实例名称。
	Name *string `json:"name,omitempty"`

	// 产品规格编码
	SpecCode *string `json:"spec_code,omitempty"`

	// 子网ID。
	SubnetId *string `json:"subnet_id,omitempty"`

	// 子网名称。
	SubnetName *string `json:"subnet_name,omitempty"`

	// 子网网段。
	SubnetCidr *string `json:"subnet_cidr,omitempty"`

	// 缓存版本。
	EngineVersion *string `json:"engine_version,omitempty"`

	// 订单ID。
	OrderId *string `json:"order_id,omitempty"`

	// 缓存实例的状态。详细状态说明见[缓存实例状态说明](https://support.huaweicloud.com/api-dcs/dcs-api-0312047.html)
	Status *string `json:"status,omitempty"`

	// 实例的域名。
	DomainName *string `json:"domain_name,omitempty"`

	// 实例的只读域名，只有主备实例有该字段。
	ReadonlyDomainName *string `json:"readonly_domain_name,omitempty"`

	// Redis缓存实例是否开启公网访问功能。 - true：开启 - false：不开启
	EnablePublicip *bool `json:"enable_publicip,omitempty"`

	// Redis缓存实例绑定的弹性IP地址的id。 如果未开启公网访问功能，该字段值为null。
	PublicipId *string `json:"publicip_id,omitempty"`

	// Redis缓存实例绑定的弹性IP地址。 如果未开启公网访问功能，该字段值为null。
	PublicipAddress *string `json:"publicip_address,omitempty"`

	// Redis缓存实例开启公网访问功能时，是否选择支持ssl。 - true：开启 - false：不开启
	EnableSsl *bool `json:"enable_ssl,omitempty"`

	// 实例是否存在升级任务。 - true：存在 - false：不存在
	ServiceUpgrade *bool `json:"service_upgrade,omitempty"`

	// 升级任务的ID。 - 当service_upgrade为true时，为升级任务的ID。 - 当service_upgrade为false时，该参数为空。
	ServiceTaskId *string `json:"service_task_id,omitempty"`

	// 企业项目ID。
	EnterpriseProjectId *string `json:"enterprise_project_id,omitempty"`

	// 集群实例的后端服务地址。
	BackendAddrs *string `json:"backend_addrs,omitempty"`

	Features *Features `json:"features,omitempty"`

	DomainNameInfo *DomainNameInfo `json:"domain_name_info,omitempty"`

	// 是否开启客户端ip透传。
	TransparentClientIpEnable *bool `json:"transparent_client_ip_enable,omitempty"`

	// 实例子状态。
	SubStatus *string `json:"sub_status,omitempty"`

	// 实例标签键值。
	Tags *[]ResourceTag `json:"tags,omitempty"`

	// 实例CPU类型，通常为x86_64或aarch64
	CpuType *string `json:"cpu_type,omitempty"`

	// 企业项目名称。
	EnterpriseProjectName *string `json:"enterprise_project_name,omitempty"`

	// 更新时间，形如2022-07-06T09:32:16.502Z
	UpdateAt *string `json:"update_at,omitempty"`

	// 版本类型：社区版、企业版
	ProductType *ShowInstanceResponseProductType `json:"product_type,omitempty"`

	// 存储类型：内存存储
	StorageType *ShowInstanceResponseStorageType `json:"storage_type,omitempty"`

	// 启动时间，形如2022-07-06T09:32:16.502Z
	LaunchedAt *string `json:"launched_at,omitempty"`

	// 缓存类型：单机类型，主备类型，主备读写分离，Proxy集群类型，原生集群类型
	CacheMode *ShowInstanceResponseCacheMode `json:"cache_mode,omitempty"`

	// 是否支持慢日志
	SupportSlowLogFlag *string `json:"support_slow_log_flag,omitempty"`

	// 数据库数量
	DbNumber *int32 `json:"db_number,omitempty"`

	// 副本数
	ReplicaCount *int32 `json:"replica_count,omitempty"`

	// 集群实例分片个数
	ShardingCount *int32 `json:"sharding_count,omitempty"`

	BandwidthInfo  *BandwidthInfo `json:"bandwidth_info,omitempty"`
	HttpStatusCode int            `json:"-"`
}

ShowInstanceResponse Response Object

func (ShowInstanceResponse) String 

func (o ShowInstanceResponse) String() string

type ShowInstanceResponseCacheMode 

type ShowInstanceResponseCacheMode struct {
	// contains filtered or unexported fields
}

func (ShowInstanceResponseCacheMode) MarshalJSON 

func (c ShowInstanceResponseCacheMode) MarshalJSON() ([]byte, error)

func (*ShowInstanceResponseCacheMode) UnmarshalJSON 

func (c *ShowInstanceResponseCacheMode) UnmarshalJSON(b []byte) error

func (ShowInstanceResponseCacheMode) Value 

func (c ShowInstanceResponseCacheMode) Value() string

type ShowInstanceResponseCacheModeEnum 

type ShowInstanceResponseCacheModeEnum struct {
	SINGLE      ShowInstanceResponseCacheMode
	HA          ShowInstanceResponseCacheMode
	HA_RW_SPLIT ShowInstanceResponseCacheMode
	PROXY       ShowInstanceResponseCacheMode
	CLUSTER     ShowInstanceResponseCacheMode
}

func GetShowInstanceResponseCacheModeEnum 

func GetShowInstanceResponseCacheModeEnum() ShowInstanceResponseCacheModeEnum

type ShowInstanceResponseProductType 

type ShowInstanceResponseProductType struct {
	// contains filtered or unexported fields
}

func (ShowInstanceResponseProductType) MarshalJSON 

func (c ShowInstanceResponseProductType) MarshalJSON() ([]byte, error)

func (*ShowInstanceResponseProductType) UnmarshalJSON 

func (c *ShowInstanceResponseProductType) UnmarshalJSON(b []byte) error

func (ShowInstanceResponseProductType) Value 

func (c ShowInstanceResponseProductType) Value() string

type ShowInstanceResponseProductTypeEnum 

type ShowInstanceResponseProductTypeEnum struct {
	GENERIC    ShowInstanceResponseProductType
	ENTERPRISE ShowInstanceResponseProductType
}

func GetShowInstanceResponseProductTypeEnum 

func GetShowInstanceResponseProductTypeEnum() ShowInstanceResponseProductTypeEnum

type ShowInstanceResponseStorageType 

type ShowInstanceResponseStorageType struct {
	// contains filtered or unexported fields
}

func (ShowInstanceResponseStorageType) MarshalJSON 

func (c ShowInstanceResponseStorageType) MarshalJSON() ([]byte, error)

func (*ShowInstanceResponseStorageType) UnmarshalJSON 

func (c *ShowInstanceResponseStorageType) UnmarshalJSON(b []byte) error

func (ShowInstanceResponseStorageType) Value 

func (c ShowInstanceResponseStorageType) Value() string

type ShowInstanceResponseStorageTypeEnum 

type ShowInstanceResponseStorageTypeEnum struct {
	DRAM ShowInstanceResponseStorageType
}

func GetShowInstanceResponseStorageTypeEnum 

func GetShowInstanceResponseStorageTypeEnum() ShowInstanceResponseStorageTypeEnum

type ShowIpWhitelistRequest 

type ShowIpWhitelistRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

ShowIpWhitelistRequest Request Object

func (ShowIpWhitelistRequest) String 

func (o ShowIpWhitelistRequest) String() string

type ShowIpWhitelistResponse 

type ShowIpWhitelistResponse struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 是否启用白名单（true/false）。
	EnableWhitelist *bool `json:"enable_whitelist,omitempty"`

	// IP白名单分组列表。
	Whitelist      *[]Whitelist `json:"whitelist,omitempty"`
	HttpStatusCode int          `json:"-"`
}

ShowIpWhitelistResponse Response Object

func (ShowIpWhitelistResponse) String 

func (o ShowIpWhitelistResponse) String() string

type ShowJobInfoRequest 

type ShowJobInfoRequest struct {

	// Job任务ID。
	JobId string `json:"job_id"`
}

ShowJobInfoRequest Request Object

func (ShowJobInfoRequest) String 

func (o ShowJobInfoRequest) String() string

type ShowJobInfoResponse 

type ShowJobInfoResponse struct {

	// Job任务ID
	JobId *string `json:"job_id,omitempty"`

	// Job类型，取值范围：   masterStandbySwapJob：主备倒换任务   modifyClientIpTransJob：修改源ip透传
	JobType *ShowJobInfoResponseJobType `json:"job_type,omitempty"`

	// Job状态
	Status *ShowJobInfoResponseStatus `json:"status,omitempty"`

	// Job开始时间戳，单位为ms，格式为:1684191545379
	BeginTime *string `json:"begin_time,omitempty"`

	// Job开始时间戳，单位为ms，格式为:1684191548248
	EndTime *string `json:"end_time,omitempty"`

	// 失败原因
	FailReason     *string `json:"fail_reason,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowJobInfoResponse Response Object

func (ShowJobInfoResponse) String 

func (o ShowJobInfoResponse) String() string

type ShowJobInfoResponseJobType 

type ShowJobInfoResponseJobType struct {
	// contains filtered or unexported fields
}

func (ShowJobInfoResponseJobType) MarshalJSON 

func (c ShowJobInfoResponseJobType) MarshalJSON() ([]byte, error)

func (*ShowJobInfoResponseJobType) UnmarshalJSON 

func (c *ShowJobInfoResponseJobType) UnmarshalJSON(b []byte) error

func (ShowJobInfoResponseJobType) Value 

func (c ShowJobInfoResponseJobType) Value() string

type ShowJobInfoResponseJobTypeEnum 

type ShowJobInfoResponseJobTypeEnum struct {
	MASTER_STANDBY_SWAP_JOB    ShowJobInfoResponseJobType
	MODIFY_CLIENT_IP_TRANS_JOB ShowJobInfoResponseJobType
}

func GetShowJobInfoResponseJobTypeEnum 

func GetShowJobInfoResponseJobTypeEnum() ShowJobInfoResponseJobTypeEnum

type ShowJobInfoResponseStatus 

type ShowJobInfoResponseStatus struct {
	// contains filtered or unexported fields
}

func (ShowJobInfoResponseStatus) MarshalJSON 

func (c ShowJobInfoResponseStatus) MarshalJSON() ([]byte, error)

func (*ShowJobInfoResponseStatus) UnmarshalJSON 

func (c *ShowJobInfoResponseStatus) UnmarshalJSON(b []byte) error

func (ShowJobInfoResponseStatus) Value 

func (c ShowJobInfoResponseStatus) Value() string

type ShowJobInfoResponseStatusEnum 

type ShowJobInfoResponseStatusEnum struct {
	INIT    ShowJobInfoResponseStatus
	RUNNING ShowJobInfoResponseStatus
	SUCCESS ShowJobInfoResponseStatus
	FAIL    ShowJobInfoResponseStatus
}

func GetShowJobInfoResponseStatusEnum 

func GetShowJobInfoResponseStatusEnum() ShowJobInfoResponseStatusEnum

type ShowMigrationTaskRequest 

type ShowMigrationTaskRequest struct {

	// 任务ID。
	TaskId string `json:"task_id"`
}

ShowMigrationTaskRequest Request Object

func (ShowMigrationTaskRequest) String 

func (o ShowMigrationTaskRequest) String() string

type ShowMigrationTaskResponse 

type ShowMigrationTaskResponse struct {

	// 迁移任务ID。
	TaskId *string `json:"task_id,omitempty"`

	// 迁移任务名称。
	TaskName *string `json:"task_name,omitempty"`

	// 迁移任务描述。
	Description *string `json:"description,omitempty"`

	// 迁移任务状态，这个字段的值包括：SUCCESS, FAILED, MIGRATING，TERMINATED。
	Status *ShowMigrationTaskResponseStatus `json:"status,omitempty"`

	// 迁移任务类型,包括备份文件导入和在线迁移两种类型。
	MigrationType *ShowMigrationTaskResponseMigrationType `json:"migration_type,omitempty"`

	// 迁移方式，包括全量迁移和增量迁移两种类型。
	MigrationMethod *ShowMigrationTaskResponseMigrationMethod `json:"migration_method,omitempty"`

	// 迁移机租户侧私有IP，与目的/源redis私有IP处于同VPC，可将此IP加入白名单
	EcsTenantPrivateIp *string `json:"ecs_tenant_private_ip,omitempty"`

	BackupFiles *BackupFilesBody `json:"backup_files,omitempty"`

	// 网络类型，包括vpc和vpn两种类型。
	NetworkType *ShowMigrationTaskResponseNetworkType `json:"network_type,omitempty"`

	SourceInstance *SourceInstanceBody `json:"source_instance,omitempty"`

	TargetInstance *TargetInstanceBody `json:"target_instance,omitempty"`

	// 迁移任务创建时间。
	CreatedAt *string `json:"created_at,omitempty"`

	// 迁移任务完成时间。
	UpdatedAt      *string `json:"updated_at,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowMigrationTaskResponse Response Object

func (ShowMigrationTaskResponse) String 

func (o ShowMigrationTaskResponse) String() string

type ShowMigrationTaskResponseMigrationMethod 

type ShowMigrationTaskResponseMigrationMethod struct {
	// contains filtered or unexported fields
}

func (ShowMigrationTaskResponseMigrationMethod) MarshalJSON 

func (c ShowMigrationTaskResponseMigrationMethod) MarshalJSON() ([]byte, error)

func (*ShowMigrationTaskResponseMigrationMethod) UnmarshalJSON 

func (c *ShowMigrationTaskResponseMigrationMethod) UnmarshalJSON(b []byte) error

func (ShowMigrationTaskResponseMigrationMethod) Value 

func (c ShowMigrationTaskResponseMigrationMethod) Value() string

type ShowMigrationTaskResponseMigrationMethodEnum 

type ShowMigrationTaskResponseMigrationMethodEnum struct {
	FULL_AMOUNT_MIGRATION ShowMigrationTaskResponseMigrationMethod
	INCREMENTAL_MIGRATION ShowMigrationTaskResponseMigrationMethod
}

func GetShowMigrationTaskResponseMigrationMethodEnum 

func GetShowMigrationTaskResponseMigrationMethodEnum() ShowMigrationTaskResponseMigrationMethodEnum

type ShowMigrationTaskResponseMigrationType 

type ShowMigrationTaskResponseMigrationType struct {
	// contains filtered or unexported fields
}

func (ShowMigrationTaskResponseMigrationType) MarshalJSON 

func (c ShowMigrationTaskResponseMigrationType) MarshalJSON() ([]byte, error)

func (*ShowMigrationTaskResponseMigrationType) UnmarshalJSON 

func (c *ShowMigrationTaskResponseMigrationType) UnmarshalJSON(b []byte) error

func (ShowMigrationTaskResponseMigrationType) Value 

func (c ShowMigrationTaskResponseMigrationType) Value() string

type ShowMigrationTaskResponseMigrationTypeEnum 

type ShowMigrationTaskResponseMigrationTypeEnum struct {
	BACKUPFILE_IMPORT ShowMigrationTaskResponseMigrationType
	ONLINE_MIGRATION  ShowMigrationTaskResponseMigrationType
}

func GetShowMigrationTaskResponseMigrationTypeEnum 

func GetShowMigrationTaskResponseMigrationTypeEnum() ShowMigrationTaskResponseMigrationTypeEnum

type ShowMigrationTaskResponseNetworkType 

type ShowMigrationTaskResponseNetworkType struct {
	// contains filtered or unexported fields
}

func (ShowMigrationTaskResponseNetworkType) MarshalJSON 

func (c ShowMigrationTaskResponseNetworkType) MarshalJSON() ([]byte, error)

func (*ShowMigrationTaskResponseNetworkType) UnmarshalJSON 

func (c *ShowMigrationTaskResponseNetworkType) UnmarshalJSON(b []byte) error

func (ShowMigrationTaskResponseNetworkType) Value 

func (c ShowMigrationTaskResponseNetworkType) Value() string

type ShowMigrationTaskResponseNetworkTypeEnum 

type ShowMigrationTaskResponseNetworkTypeEnum struct {
	VPC ShowMigrationTaskResponseNetworkType
	VPN ShowMigrationTaskResponseNetworkType
}

func GetShowMigrationTaskResponseNetworkTypeEnum 

func GetShowMigrationTaskResponseNetworkTypeEnum() ShowMigrationTaskResponseNetworkTypeEnum

type ShowMigrationTaskResponseStatus 

type ShowMigrationTaskResponseStatus struct {
	// contains filtered or unexported fields
}

func (ShowMigrationTaskResponseStatus) MarshalJSON 

func (c ShowMigrationTaskResponseStatus) MarshalJSON() ([]byte, error)

func (*ShowMigrationTaskResponseStatus) UnmarshalJSON 

func (c *ShowMigrationTaskResponseStatus) UnmarshalJSON(b []byte) error

func (ShowMigrationTaskResponseStatus) Value 

func (c ShowMigrationTaskResponseStatus) Value() string

type ShowMigrationTaskResponseStatusEnum 

type ShowMigrationTaskResponseStatusEnum struct {
	SUCCESS    ShowMigrationTaskResponseStatus
	FAILED     ShowMigrationTaskResponseStatus
	MIGRATING  ShowMigrationTaskResponseStatus
	TERMINATED ShowMigrationTaskResponseStatus
}

func GetShowMigrationTaskResponseStatusEnum 

func GetShowMigrationTaskResponseStatusEnum() ShowMigrationTaskResponseStatusEnum

type ShowMigrationTaskStatsRequest 

type ShowMigrationTaskStatsRequest struct {

	// 任务ID。
	TaskId string `json:"task_id"`
}

ShowMigrationTaskStatsRequest Request Object

func (ShowMigrationTaskStatsRequest) String 

func (o ShowMigrationTaskStatsRequest) String() string

type ShowMigrationTaskStatsResponse 

type ShowMigrationTaskStatsResponse struct {

	// 全量迁移进度百分比。
	FullMigrationProgress *string `json:"full_migration_progress,omitempty"`

	// 增量迁移偏移量。
	Offset *string `json:"offset,omitempty"`

	// 源redis键数量
	SourceDbsize *string `json:"source_dbsize,omitempty"`

	// 目标redis键数量
	TargetDbsize *string `json:"target_dbsize,omitempty"`

	// 目标redis键写入流量，单位KB/s
	TargetInputKbps *string `json:"target_input_kbps,omitempty"`

	// 目标redis每秒并发操作数
	TargetOps *string `json:"target_ops,omitempty"`

	// 迁移任务是否在进行
	IsMigrating    *bool `json:"is_migrating,omitempty"`
	HttpStatusCode int   `json:"-"`
}

ShowMigrationTaskStatsResponse Response Object

func (ShowMigrationTaskStatsResponse) String 

func (o ShowMigrationTaskStatsResponse) String() string

type ShowQuotaOfTenantRequest 

type ShowQuotaOfTenantRequest struct {
}

ShowQuotaOfTenantRequest Request Object

func (ShowQuotaOfTenantRequest) String 

func (o ShowQuotaOfTenantRequest) String() string

type ShowQuotaOfTenantResponse 

type ShowQuotaOfTenantResponse struct {
	Quotas         *QueryTenantQuotaRespQuotas `json:"quotas,omitempty"`
	HttpStatusCode int                         `json:"-"`
}

ShowQuotaOfTenantResponse Response Object

func (ShowQuotaOfTenantResponse) String 

func (o ShowQuotaOfTenantResponse) String() string

type ShowTagsRequest 

type ShowTagsRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`
}

ShowTagsRequest Request Object

func (ShowTagsRequest) String 

func (o ShowTagsRequest) String() string

type ShowTagsResponse 

type ShowTagsResponse struct {

	// 标签列表。
	Tags           *[]ResourceTag `json:"tags,omitempty"`
	HttpStatusCode int            `json:"-"`
}

ShowTagsResponse Response Object

func (ShowTagsResponse) String 

func (o ShowTagsResponse) String() string

type SingleBackgroundTask 

type SingleBackgroundTask struct {

	// 后台任务ID
	Id *string `json:"id,omitempty"`

	// 后台任务名，目前支持以下取值：  ChangeInstanceSpec：变更规格  BindEip：开启公网访问  UnBindEip：关闭公网访问  AddReplica：添加副本  DelReplica：删除副本  AddWhitelist：设置IP白名单  UpdatePort：修改端口  RemoveIpFromDns：域名摘除IP
	Name *string `json:"name,omitempty"`

	Details *DetailsBody `json:"details,omitempty"`

	// 用户名
	UserName *string `json:"user_name,omitempty"`

	// 用户ID
	UserId *string `json:"user_id,omitempty"`

	// 任务相关参数
	Params *string `json:"params,omitempty"`

	// 任务状态
	Status *string `json:"status,omitempty"`

	// 任务启动时间，格式为2020-06-17T07:38:42.503Z
	CreatedAt *string `json:"created_at,omitempty"`

	// 任务结束时间，格式为2020-06-17T07:38:42.503Z
	UpdatedAt *string `json:"updated_at,omitempty"`

	// 是否有详细任务进展，可以展开查看
	EnableShow *bool `json:"enable_show,omitempty"`
}

SingleBackgroundTask 单个任务结构体

func (SingleBackgroundTask) String 

func (o SingleBackgroundTask) String() string

type SlowlogItem 

type SlowlogItem struct {

	// 慢日志的唯一标识
	Id *int32 `json:"id,omitempty"`

	// 慢命令
	Command *string `json:"command,omitempty"`

	// 执行开始时间,格式为“2020-06-19T07:06:07Z”
	StartTime *string `json:"start_time,omitempty"`

	// 持续时间，单位是ms
	Duration *string `json:"duration,omitempty"`

	// 慢命令所在的分片名称，仅在实例类型为集群时支持
	ShardName *string `json:"shard_name,omitempty"`
}

SlowlogItem 慢日志单个条目

func (SlowlogItem) String 

func (o SlowlogItem) String() string

type SourceInstanceBody 

type SourceInstanceBody struct {

	// Redis实例名称(source_instance信息中填写)。
	Addrs string `json:"addrs"`

	// Redis密码，如果设置了密码，则必须填写。
	Password *string `json:"password,omitempty"`
}

SourceInstanceBody 源实例信息。

func (SourceInstanceBody) String 

func (o SourceInstanceBody) String() string

type StatusStatistic 

type StatusStatistic struct {

	// 支付中的实例数。
	PayingCount *int32 `json:"paying_count,omitempty"`

	// 冻结中的实例数。
	FreezingCount *int32 `json:"freezing_count,omitempty"`

	// 迁移中的实例数。
	MigratingCount *int32 `json:"migrating_count,omitempty"`

	// 清空中的实例数。
	FlushingCount *int32 `json:"flushing_count,omitempty"`

	// 升级中的实例数。
	UpgradingCount *int32 `json:"upgrading_count,omitempty"`

	// 恢复中的实例数。
	RestoringCount *int32 `json:"restoring_count,omitempty"`

	// 扩容中的实例数。
	ExtendingCount *int32 `json:"extending_count,omitempty"`

	// 正在创建的实例数。
	CreatingCount *int32 `json:"creating_count,omitempty"`

	// 正在运行的实例数。
	RunningCount *int32 `json:"running_count,omitempty"`

	// 异常的实例数。
	ErrorCount *int32 `json:"error_count,omitempty"`

	// 已冻结的实例数。
	FrozenCount *int32 `json:"frozen_count,omitempty"`

	// 创建失败的实例数。
	CreatefailedCount *int32 `json:"createfailed_count,omitempty"`

	// 正在重启的实例数。
	RestartingCount *int32 `json:"restarting_count,omitempty"`
}

StatusStatistic 实例数量统计信息。

func (StatusStatistic) String 

func (o StatusStatistic) String() string

type StopMigrationTaskRequest 

type StopMigrationTaskRequest struct {

	// 任务ID
	TaskId string `json:"task_id"`
}

StopMigrationTaskRequest Request Object

func (StopMigrationTaskRequest) String 

func (o StopMigrationTaskRequest) String() string

type StopMigrationTaskResponse 

type StopMigrationTaskResponse struct {

	// 迁移任务ID。
	TaskId *string `json:"task_id,omitempty"`

	// 迁移任务名称。
	TaskName *string `json:"task_name,omitempty"`

	// 迁移任务描述。
	Description *string `json:"description,omitempty"`

	// 迁移任务状态，这个字段的值包括：SUCCESS, FAILED, MIGRATING，TERMINATED。
	Status *StopMigrationTaskResponseStatus `json:"status,omitempty"`

	// 迁移任务类型,包括备份文件导入和在线迁移两种类型。
	MigrationType *StopMigrationTaskResponseMigrationType `json:"migration_type,omitempty"`

	// 迁移方式，包括全量迁移和增量迁移两种类型。
	MigrationMethod *StopMigrationTaskResponseMigrationMethod `json:"migration_method,omitempty"`

	// 迁移机租户侧私有IP，与目的/源redis私有IP处于同VPC，可将此IP加入白名单
	EcsTenantPrivateIp *string `json:"ecs_tenant_private_ip,omitempty"`

	BackupFiles *BackupFilesBody `json:"backup_files,omitempty"`

	// 网络类型，包括vpc和vpn两种类型。
	NetworkType *StopMigrationTaskResponseNetworkType `json:"network_type,omitempty"`

	SourceInstance *SourceInstanceBody `json:"source_instance,omitempty"`

	TargetInstance *TargetInstanceBody `json:"target_instance,omitempty"`

	// 迁移任务创建时间。
	CreatedAt *string `json:"created_at,omitempty"`

	// 迁移任务完成时间。
	UpdatedAt      *string `json:"updated_at,omitempty"`
	HttpStatusCode int     `json:"-"`
}

StopMigrationTaskResponse Response Object

func (StopMigrationTaskResponse) String 

func (o StopMigrationTaskResponse) String() string

type StopMigrationTaskResponseMigrationMethod 

type StopMigrationTaskResponseMigrationMethod struct {
	// contains filtered or unexported fields
}

func (StopMigrationTaskResponseMigrationMethod) MarshalJSON 

func (c StopMigrationTaskResponseMigrationMethod) MarshalJSON() ([]byte, error)

func (*StopMigrationTaskResponseMigrationMethod) UnmarshalJSON 

func (c *StopMigrationTaskResponseMigrationMethod) UnmarshalJSON(b []byte) error

func (StopMigrationTaskResponseMigrationMethod) Value 

func (c StopMigrationTaskResponseMigrationMethod) Value() string

type StopMigrationTaskResponseMigrationMethodEnum 

type StopMigrationTaskResponseMigrationMethodEnum struct {
	FULL_AMOUNT_MIGRATION StopMigrationTaskResponseMigrationMethod
	INCREMENTAL_MIGRATION StopMigrationTaskResponseMigrationMethod
}

func GetStopMigrationTaskResponseMigrationMethodEnum 

func GetStopMigrationTaskResponseMigrationMethodEnum() StopMigrationTaskResponseMigrationMethodEnum

type StopMigrationTaskResponseMigrationType 

type StopMigrationTaskResponseMigrationType struct {
	// contains filtered or unexported fields
}

func (StopMigrationTaskResponseMigrationType) MarshalJSON 

func (c StopMigrationTaskResponseMigrationType) MarshalJSON() ([]byte, error)

func (*StopMigrationTaskResponseMigrationType) UnmarshalJSON 

func (c *StopMigrationTaskResponseMigrationType) UnmarshalJSON(b []byte) error

func (StopMigrationTaskResponseMigrationType) Value 

func (c StopMigrationTaskResponseMigrationType) Value() string

type StopMigrationTaskResponseMigrationTypeEnum 

type StopMigrationTaskResponseMigrationTypeEnum struct {
	BACKUPFILE_IMPORT StopMigrationTaskResponseMigrationType
	ONLINE_MIGRATION  StopMigrationTaskResponseMigrationType
}

func GetStopMigrationTaskResponseMigrationTypeEnum 

func GetStopMigrationTaskResponseMigrationTypeEnum() StopMigrationTaskResponseMigrationTypeEnum

type StopMigrationTaskResponseNetworkType 

type StopMigrationTaskResponseNetworkType struct {
	// contains filtered or unexported fields
}

func (StopMigrationTaskResponseNetworkType) MarshalJSON 

func (c StopMigrationTaskResponseNetworkType) MarshalJSON() ([]byte, error)

func (*StopMigrationTaskResponseNetworkType) UnmarshalJSON 

func (c *StopMigrationTaskResponseNetworkType) UnmarshalJSON(b []byte) error

func (StopMigrationTaskResponseNetworkType) Value 

func (c StopMigrationTaskResponseNetworkType) Value() string

type StopMigrationTaskResponseNetworkTypeEnum 

type StopMigrationTaskResponseNetworkTypeEnum struct {
	VPC StopMigrationTaskResponseNetworkType
	VPN StopMigrationTaskResponseNetworkType
}

func GetStopMigrationTaskResponseNetworkTypeEnum 

func GetStopMigrationTaskResponseNetworkTypeEnum() StopMigrationTaskResponseNetworkTypeEnum

type StopMigrationTaskResponseStatus 

type StopMigrationTaskResponseStatus struct {
	// contains filtered or unexported fields
}

func (StopMigrationTaskResponseStatus) MarshalJSON 

func (c StopMigrationTaskResponseStatus) MarshalJSON() ([]byte, error)

func (*StopMigrationTaskResponseStatus) UnmarshalJSON 

func (c *StopMigrationTaskResponseStatus) UnmarshalJSON(b []byte) error

func (StopMigrationTaskResponseStatus) Value 

func (c StopMigrationTaskResponseStatus) Value() string

type StopMigrationTaskResponseStatusEnum 

type StopMigrationTaskResponseStatusEnum struct {
	SUCCESS    StopMigrationTaskResponseStatus
	FAILED     StopMigrationTaskResponseStatus
	MIGRATING  StopMigrationTaskResponseStatus
	TERMINATED StopMigrationTaskResponseStatus
}

func GetStopMigrationTaskResponseStatusEnum 

func GetStopMigrationTaskResponseStatusEnum() StopMigrationTaskResponseStatusEnum

type StopMigrationTaskResult 

type StopMigrationTaskResult struct {

	// 下发停止迁移任务操作结果。
	Result *StopMigrationTaskResultResult `json:"result,omitempty"`

	// 数据迁移任务ID。
	TaskId *string `json:"task_id,omitempty"`
}

func (StopMigrationTaskResult) String 

func (o StopMigrationTaskResult) String() string

type StopMigrationTaskResultResult 

type StopMigrationTaskResultResult struct {
	// contains filtered or unexported fields
}

func (StopMigrationTaskResultResult) MarshalJSON 

func (c StopMigrationTaskResultResult) MarshalJSON() ([]byte, error)

func (*StopMigrationTaskResultResult) UnmarshalJSON 

func (c *StopMigrationTaskResultResult) UnmarshalJSON(b []byte) error

func (StopMigrationTaskResultResult) Value 

func (c StopMigrationTaskResultResult) Value() string

type StopMigrationTaskResultResultEnum 

type StopMigrationTaskResultResultEnum struct {
	SUCCESS StopMigrationTaskResultResult
	FAILED  StopMigrationTaskResultResult
}

func GetStopMigrationTaskResultResultEnum 

func GetStopMigrationTaskResultResultEnum() StopMigrationTaskResultResultEnum

type StopMigrationTaskSyncRequest 

type StopMigrationTaskSyncRequest struct {

	// 任务ID
	TaskId string `json:"task_id"`
}

StopMigrationTaskSyncRequest Request Object

func (StopMigrationTaskSyncRequest) String 

func (o StopMigrationTaskSyncRequest) String() string

type StopMigrationTaskSyncResponse 

type StopMigrationTaskSyncResponse struct {
	HttpStatusCode int `json:"-"`
}

StopMigrationTaskSyncResponse Response Object

func (StopMigrationTaskSyncResponse) String 

func (o StopMigrationTaskSyncResponse) String() string

type Tag 

type Tag struct {

	// 标签键，最大长度36个unicode字符。
	Key *string `json:"key,omitempty"`

	// 标签值
	Values *[]string `json:"values,omitempty"`
}

func (Tag) String 

func (o Tag) String() string

type TargetInstanceBody 

type TargetInstanceBody struct {

	// Redis实例ID（target_instance信息中必须填写）。
	Id string `json:"id"`

	// Redis实例名称(target_instance信息中填写)。
	Name *string `json:"name,omitempty"`

	// Redis密码，如果设置了密码，则必须填写。
	Password *string `json:"password,omitempty"`
}

TargetInstanceBody 目标实例信息。

func (TargetInstanceBody) String 

func (o TargetInstanceBody) String() string

type UpdateBigkeyAutoscanConfigRequest 

type UpdateBigkeyAutoscanConfigRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *AutoscanConfigRequest `json:"body,omitempty"`
}

UpdateBigkeyAutoscanConfigRequest Request Object

func (UpdateBigkeyAutoscanConfigRequest) String 

func (o UpdateBigkeyAutoscanConfigRequest) String() string

type UpdateBigkeyAutoscanConfigResponse 

type UpdateBigkeyAutoscanConfigResponse struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 是否开启自动分析
	EnableAutoScan *bool `json:"enable_auto_scan,omitempty"`

	// 每日分析时间，时间格式为21:00
	ScheduleAt *[]string `json:"schedule_at,omitempty"`

	// 配置更新时间，时间格式为2020-06-15T02:21:18.669Z
	UpdatedAt      *string `json:"updated_at,omitempty"`
	HttpStatusCode int     `json:"-"`
}

UpdateBigkeyAutoscanConfigResponse Response Object

func (UpdateBigkeyAutoscanConfigResponse) String 

func (o UpdateBigkeyAutoscanConfigResponse) String() string

type UpdateConfigurationsRequest 

type UpdateConfigurationsRequest struct {

	// 实例ID
	InstanceId string `json:"instance_id"`

	Body *ModifyRedisConfigBody `json:"body,omitempty"`
}

UpdateConfigurationsRequest Request Object

func (UpdateConfigurationsRequest) String 

func (o UpdateConfigurationsRequest) String() string

type UpdateConfigurationsResponse 

type UpdateConfigurationsResponse struct {
	HttpStatusCode int `json:"-"`
}

UpdateConfigurationsResponse Response Object

func (UpdateConfigurationsResponse) String 

func (o UpdateConfigurationsResponse) String() string

type UpdateHotkeyAutoScanConfigRequest 

type UpdateHotkeyAutoScanConfigRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *AutoscanConfigRequest `json:"body,omitempty"`
}

UpdateHotkeyAutoScanConfigRequest Request Object

func (UpdateHotkeyAutoScanConfigRequest) String 

func (o UpdateHotkeyAutoScanConfigRequest) String() string

type UpdateHotkeyAutoScanConfigResponse 

type UpdateHotkeyAutoScanConfigResponse struct {

	// 实例ID
	InstanceId *string `json:"instance_id,omitempty"`

	// 是否开启自动分析
	EnableAutoScan *bool `json:"enable_auto_scan,omitempty"`

	// 每日分析时间，时间格式为21:00
	ScheduleAt *[]string `json:"schedule_at,omitempty"`

	// 配置更新时间，时间格式为2020-06-15T02:21:18.669Z
	UpdatedAt      *string `json:"updated_at,omitempty"`
	HttpStatusCode int     `json:"-"`
}

UpdateHotkeyAutoScanConfigResponse Response Object

func (UpdateHotkeyAutoScanConfigResponse) String 

func (o UpdateHotkeyAutoScanConfigResponse) String() string

type UpdateInstanceBandwidthRequest 

type UpdateInstanceBandwidthRequest struct {

	// 实例ID
	InstanceId string `json:"instance_id"`
}

UpdateInstanceBandwidthRequest Request Object

func (UpdateInstanceBandwidthRequest) String 

func (o UpdateInstanceBandwidthRequest) String() string

type UpdateInstanceBandwidthResponse 

type UpdateInstanceBandwidthResponse struct {
	HttpStatusCode int `json:"-"`
}

UpdateInstanceBandwidthResponse Response Object

func (UpdateInstanceBandwidthResponse) String 

func (o UpdateInstanceBandwidthResponse) String() string

type UpdateInstanceRequest 

type UpdateInstanceRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *ModifyInstanceBody `json:"body,omitempty"`
}

UpdateInstanceRequest Request Object

func (UpdateInstanceRequest) String 

func (o UpdateInstanceRequest) String() string

type UpdateInstanceResponse 

type UpdateInstanceResponse struct {
	HttpStatusCode int `json:"-"`
}

UpdateInstanceResponse Response Object

func (UpdateInstanceResponse) String 

func (o UpdateInstanceResponse) String() string

type UpdateIpWhitelistRequest 

type UpdateIpWhitelistRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *ModifyIpWhitelistBody `json:"body,omitempty"`
}

UpdateIpWhitelistRequest Request Object

func (UpdateIpWhitelistRequest) String 

func (o UpdateIpWhitelistRequest) String() string

type UpdateIpWhitelistResponse 

type UpdateIpWhitelistResponse struct {
	HttpStatusCode int `json:"-"`
}

UpdateIpWhitelistResponse Response Object

func (UpdateIpWhitelistResponse) String 

func (o UpdateIpWhitelistResponse) String() string

type UpdatePasswordRequest 

type UpdatePasswordRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	Body *ModifyInstancePasswordBody `json:"body,omitempty"`
}

UpdatePasswordRequest Request Object

func (UpdatePasswordRequest) String 

func (o UpdatePasswordRequest) String() string

type UpdatePasswordResponse 

type UpdatePasswordResponse struct {

	// 锁定时间。验证失败时和锁定时该参数返回不为null
	LockTime *string `json:"lock_time,omitempty"`

	// 密码修改结果： - 成功：success； - 密码验证失败：passwordFailed； - 已锁定：locked； - 失败：failed。
	Result *UpdatePasswordResponseResult `json:"result,omitempty"`

	// 锁定剩余时间。锁定时该参数返回不为null
	LockTimeLeft *string `json:"lock_time_left,omitempty"`

	// 密码验证剩余次数。验证失败时该参数返回不为null
	RetryTimesLeft *string `json:"retry_times_left,omitempty"`

	// 修改结果。
	Message        *string `json:"message,omitempty"`
	HttpStatusCode int     `json:"-"`
}

UpdatePasswordResponse Response Object

func (UpdatePasswordResponse) String 

func (o UpdatePasswordResponse) String() string

type UpdatePasswordResponseResult 

type UpdatePasswordResponseResult struct {
	// contains filtered or unexported fields
}

func (UpdatePasswordResponseResult) MarshalJSON 

func (c UpdatePasswordResponseResult) MarshalJSON() ([]byte, error)

func (*UpdatePasswordResponseResult) UnmarshalJSON 

func (c *UpdatePasswordResponseResult) UnmarshalJSON(b []byte) error

func (UpdatePasswordResponseResult) Value 

func (c UpdatePasswordResponseResult) Value() string

type UpdatePasswordResponseResultEnum 

type UpdatePasswordResponseResultEnum struct {
	SUCCESS         UpdatePasswordResponseResult
	PASSWORD_FAILED UpdatePasswordResponseResult
	LOCKED          UpdatePasswordResponseResult
	FAILED          UpdatePasswordResponseResult
}

func GetUpdatePasswordResponseResultEnum 

func GetUpdatePasswordResponseResultEnum() UpdatePasswordResponseResultEnum

type UpdateSlavePriorityRequest 

type UpdateSlavePriorityRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 分片ID。
	GroupId string `json:"group_id"`

	// 节点ID。
	NodeId string `json:"node_id"`

	Body *PriorityBody `json:"body,omitempty"`
}

UpdateSlavePriorityRequest Request Object

func (UpdateSlavePriorityRequest) String 

func (o UpdateSlavePriorityRequest) String() string

type UpdateSlavePriorityResponse 

type UpdateSlavePriorityResponse struct {
	HttpStatusCode int `json:"-"`
}

UpdateSlavePriorityResponse Response Object

func (UpdateSlavePriorityResponse) String 

func (o UpdateSlavePriorityResponse) String() string

type Whitelist 

type Whitelist struct {

	// 白名单分组名称，每个实例支持创建4个分组。
	GroupName string `json:"group_name"`

	// 白名单分组下的IP列表,每个实例最多可以添加20个IP地址/地址段。如果有多个，可以用逗号分隔。不支持的IP和地址段：0.0.0.0和0.0.0.0/0
	IpList []string `json:"ip_list"`
}

Whitelist IP白名单分组列表结构体

func (Whitelist) String 

func (o Whitelist) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.