model

Documentation

Index

• type DaxctrlMem
• type LV
  • func ParseLV(line string) (*LV, error)
• type LVAttributes
• type PV
  • func ParsePV(line string) (*PV, error)
• type PmemNameSpace
• type PmemRegion
• type PmemRegions
• type ResourceYaml
• type Topology
• type VG
  • func ParseVG(line string) (*VG, error)
• type VolumeActivationSkipped
• type VolumeAllocation
• type VolumeFixedMinor
• type VolumeHealth
• type VolumeOpen
• type VolumePermissions
• type VolumeState
• type VolumeTargetType
• type VolumeType
• type VolumeZeroing

Types

type DaxctrlMem

type DaxctrlMem struct {
	Chardev    string `json:"chardev"`
	Size       int64  `json:"size"`
	TargetNode int    `json:"target_node"`
	Mode       string `json:"mode"`
	Movable    bool   `json:"movable"`
}

DaxctrlMem list all mems

type LV

type LV struct {
	Name               string
	Size               uint64
	UUID               string
	Attributes         LVAttributes
	CopyPercent        string
	ActualDevMajNumber uint32
	ActualDevMinNumber uint32
	Tags               []string
}

LV is a logical volume

func ParseLV

func ParseLV(line string) (*LV, error)

ParseLV ...

type LVAttributes

type LVAttributes struct {
	Type              VolumeType
	Permissions       VolumePermissions
	Allocation        VolumeAllocation
	FixedMinor        VolumeFixedMinor
	State             VolumeState
	Open              VolumeOpen
	TargetType        VolumeTargetType
	Zeroing           VolumeZeroing
	Health            VolumeHealth
	ActivationSkipped VolumeActivationSkipped
}

LVAttributes is attributes

type PV

type PV struct {
	Name   string
	VgName string
	Size   uint64
	UUID   string
}

PV is Physica lVolume

func ParsePV

func ParsePV(line string) (*PV, error)

ParsePV parse volume group

type PmemNameSpace

type PmemNameSpace struct {
	Dev        string `json:"dev,omitempty"`
	Mode       string `json:"mode,omitempty"`
	MapType    string `json:"map,omitempty"`
	Size       int64  `json:"size,omitempty"`
	UUID       string `json:"uuid,omitempty"`
	SectorSize int64  `json:"sectorsize,omitempty"`
	Align      int64  `json:"align,omitempty"`
	BlockDev   string `json:"blockdev,omitempty"`
	CharDev    string `json:"chardev,omitempty"`
	Name       string `json:"name,omitempty"`
}

PmemNameSpace define one pmem namespaces

type PmemRegion

type PmemRegion struct {
	Dev               string          `json:"dev"`
	Size              int64           `json:"size,omitempty"`
	AvailableSize     int64           `json:"available_size,omitempty"`
	MaxAvailableExent int64           `json:"max_available_extent,omitempty"`
	RegionType        string          `json:"type,omitempty"`
	IsetID            int64           `json:"iset_id,omitempty"`
	PersistenceDomain string          `json:"persistence_domain,omitempty"`
	Namespaces        []PmemNameSpace `json:"namespaces,omitempty"`
}

PmemRegion define on pmem region

type PmemRegions

type PmemRegions struct {
	Regions []PmemRegion `json:"regions"`
}

PmemRegions list all regions

type ResourceYaml

type ResourceYaml struct {
	Name     string                       `yaml:"name,omitempty"`
	Key      string                       `yaml:"key,omitempty"`
	Operator metav1.LabelSelectorOperator `yaml:"operator,omitempty"`
	Value    string                       `yaml:"value,omitempty"`
	Topology Topology                     `yaml:"topology,omitempty"`
}

ResourceYaml ...

type Topology

type Topology struct {
	Type    string `yaml:"type,omitempty"`
	Options string `yaml:"options,omitempty"`
	Fstype  string `yaml:"fstype,omitempty"`

	Devices []string            `yaml:"devices,omitempty"`
	Volumes []map[string]string `yaml:"volumes,omitempty"`
	Regions []string            `yaml:"regions,omitempty"`
}

Topology ...

type VG

type VG struct {
	Name     string
	Size     uint64
	FreeSize uint64
	UUID     string
	Tags     []string
}

VG is volume group

func ParseVG

func ParseVG(line string) (*VG, error)

ParseVG parse volume group

type VolumeActivationSkipped

type VolumeActivationSkipped rune

VolumeActivationSkipped is volume activation

const (
	VolumeActivationSkippedIsSkipped    VolumeActivationSkipped = 's'
	VolumeActivationSkippedIsNotSkipped VolumeActivationSkipped = '-'
)

activation

type VolumeAllocation

type VolumeAllocation rune

VolumeAllocation is volume allocation policy

const (
	VolumeAllocationAnywhere         VolumeAllocation = 'a'
	VolumeAllocationContiguous       VolumeAllocation = 'c'
	VolumeAllocationInherited        VolumeAllocation = 'i'
	VolumeAllocationCling            VolumeAllocation = 'l'
	VolumeAllocationNormal           VolumeAllocation = 'n'
	VolumeAllocationAnywhereLocked   VolumeAllocation = 'A'
	VolumeAllocationContiguousLocked VolumeAllocation = 'C'
	VolumeAllocationInheritedLocked  VolumeAllocation = 'I'
	VolumeAllocationClingLocked      VolumeAllocation = 'L'
	VolumeAllocationNormalLocked     VolumeAllocation = 'N'
)

allocations

type VolumeFixedMinor

type VolumeFixedMinor rune

VolumeFixedMinor is volume fixed minor

const (
	VolumeFixedMinorEnabled  VolumeFixedMinor = 'm'
	VolumeFixedMinorDisabled VolumeFixedMinor = '-'
)

fixed minor

type VolumeHealth

type VolumeHealth rune

VolumeHealth is volume health

const (
	VolumeHealthOK              VolumeHealth = '-'
	VolumeHealthPartial         VolumeHealth = 'p'
	VolumeHealthRefreshNeeded   VolumeHealth = 'r'
	VolumeHealthMismatchesExist VolumeHealth = 'm'
	VolumeHealthWritemostly     VolumeHealth = 'w'
)

health

type VolumeOpen

type VolumeOpen rune

VolumeOpen is volume open

const (
	VolumeOpenIsOpen    VolumeOpen = 'o'
	VolumeOpenIsNotOpen VolumeOpen = '-'
)

open

type VolumePermissions

type VolumePermissions rune

VolumePermissions is volume permissions

const (
	VolumePermissionsWriteable          VolumePermissions = 'w'
	VolumePermissionsReadOnly           VolumePermissions = 'r'
	VolumePermissionsReadOnlyActivation VolumePermissions = 'R'
)

permissions

type VolumeState

type VolumeState rune

VolumeState is volume state

const (
	VolumeStateActive                               VolumeState = 'a'
	VolumeStateSuspended                            VolumeState = 's'
	VolumeStateInvalidSnapshot                      VolumeState = 'I'
	VolumeStateInvalidSuspendedSnapshot             VolumeState = 'S'
	VolumeStateSnapshotMergeFailed                  VolumeState = 'm'
	VolumeStateSuspendedSnapshotMergeFailed         VolumeState = 'M'
	VolumeStateMappedDevicePresentWithoutTables     VolumeState = 'd'
	VolumeStateMappedDevicePresentWithInactiveTable VolumeState = 'i'
)

states

type VolumeTargetType

type VolumeTargetType rune

VolumeTargetType is volume taget type

const (
	VolumeTargetTypeMirror   VolumeTargetType = 'm'
	VolumeTargetTypeRAID     VolumeTargetType = 'r'
	VolumeTargetTypeSnapshot VolumeTargetType = 's'
	VolumeTargetTypeThin     VolumeTargetType = 't'
	VolumeTargetTypeUnknown  VolumeTargetType = 'u'
	VolumeTargetTypeVirtual  VolumeTargetType = 'v'
)

target type

type VolumeType

type VolumeType byte

VolumeType is volume type

const (
	VolumeTypeMirrored                  VolumeType = 'm'
	VolumeTypeMirroredWithoutSync       VolumeType = 'M'
	VolumeTypeOrigin                    VolumeType = 'o'
	VolumeTypeOriginWithMergingSnapshot VolumeType = 'O'
	VolumeTypeRAID                      VolumeType = 'r'
	VolumeTypeRAIDWithoutSync           VolumeType = 'R'
	VolumeTypeSnapshot                  VolumeType = 's'
	VolumeTypeMergingSnapshot           VolumeType = 'S'
	VolumeTypePVMove                    VolumeType = 'p'
	VolumeTypeVirtualMirror             VolumeType = 'v'
	VolumeTypeVirtualRaidImage          VolumeType = 'i'
	VolumeTypeRaidImageOutOfSync        VolumeType = 'I'
	VolumeTypeMirrorLog                 VolumeType = 'l'
	VolumeTypeUnderConversion           VolumeType = 'c'
	VolumeTypeThin                      VolumeType = 'V'
	VolumeTypeThinPool                  VolumeType = 't'
	VolumeTypeThinPoolData              VolumeType = 'T'
	VolumeTypeRaidOrThinPoolMetadata    VolumeType = 'e'
)

types

type VolumeZeroing

type VolumeZeroing rune

VolumeZeroing is volume zeroing

const (
	VolumeZeroingIsZeroing    VolumeZeroing = 'z'
	VolumeZeroingIsNonZeroing VolumeZeroing = '-'
)

zeroing