metal

package
Version: v0.22.0 Latest Latest
Warning

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

Go to latest
Published: Jan 27, 2023 License: AGPL-3.0 Imports: 15 Imported by: 0

Documentation

Index

Constants

View Source
const (
	// VFAT is used for the UEFI boot partition
	VFAT = Format("vfat")
	// EXT3 is usually only used for /boot
	EXT3 = Format("ext3")
	// EXT4 is the default fs
	EXT4 = Format("ext4")
	// SWAP is for the swap partition
	SWAP = Format("swap")
	// TMPFS is used for a memory filesystem typically /tmp
	TMPFS = Format("tmpfs")
	// None
	NONE = Format("none")

	// GPTBoot EFI Boot Partition
	GPTBoot = GPTType("ef00")
	// GPTLinux Linux Partition
	GPTLinux = GPTType("8300")
	// GPTLinuxRaid Linux Raid Partition
	GPTLinuxRaid = GPTType("fd00")
	// GPTLinux Linux Partition
	GPTLinuxLVM = GPTType("8e00")

	// RaidLevel0 is a stripe of two or more disks
	RaidLevel0 = RaidLevel("0")
	// RaidLevel1 is a mirror of two disks
	RaidLevel1 = RaidLevel("1")

	// LVMTypeLinear append across all physical volumes
	LVMTypeLinear = LVMType("linear")
	// LVMTypeStriped stripe across all physical volumes
	LVMTypeStriped = LVMType("striped")
	// LVMTypeStripe mirror with raid across all physical volumes
	LVMTypeRaid1 = LVMType("raid1")
)
View Source
const (
	// TagIPSeperator is the seperator character for key and values in IP-Tags
	TagIPSeperator = "="

	// Ephemeral IPs will be cleaned up automatically on machine, network, project deletion
	Ephemeral IPType = "ephemeral"
	// Static IPs will not be cleaned up and can be re-used for machines, networks within a project
	Static IPType = "static"

	// ScopeEmpty IPs are not bound to a project, machine or cluster
	ScopeEmpty IPScope = ""
	// ScopeProject IPs can be assigned to machines or used by cluster services
	ScopeProject IPScope = "project"
	// ScopeMachine IPs are bound to the usage directly at machines
	ScopeMachine IPScope = "machine"
)

Variables

View Source
var (
	SupportedFormats    = map[Format]bool{VFAT: true, EXT3: true, EXT4: true, SWAP: true, TMPFS: true, NONE: true}
	SupportedGPTTypes   = map[GPTType]bool{GPTBoot: true, GPTLinux: true, GPTLinuxLVM: true, GPTLinuxRaid: true}
	SupportedRaidLevels = map[RaidLevel]bool{RaidLevel0: true, RaidLevel1: true}
	SupportedLVMTypes   = map[LVMType]bool{LVMTypeLinear: true, LVMTypeStriped: true, LVMTypeRaid1: true}
)
View Source
var (
	// AllStates contains all possible values of a machine state
	AllStates = []MState{AvailableState, ReservedState, LockedState}
	// AllRoles contains all possible values of a role
	AllRoles = map[Role]bool{
		RoleMachine:  true,
		RoleFirewall: true,
	}
)
View Source
var (
	PrivatePrimaryUnshared = NetworkType{
		Name:           mn.PrivatePrimaryUnshared,
		Private:        true,
		PrivatePrimary: true,
		Shared:         false,
		Underlay:       false,
		Supported:      true,
	}
	PrivatePrimaryShared = NetworkType{
		Name:           mn.PrivatePrimaryShared,
		Private:        true,
		PrivatePrimary: true,
		Shared:         true,
		Underlay:       false,
		Supported:      true,
	}
	PrivateSecondaryShared = NetworkType{
		Name:           mn.PrivateSecondaryShared,
		Private:        true,
		PrivatePrimary: false,
		Shared:         true,
		Underlay:       false,
		Supported:      true,
	}
	// PrivateSecondaryUnshared this case is not a valid configuration
	PrivateSecondaryUnshared = NetworkType{
		Name:           mn.PrivateSecondaryUnshared,
		Private:        true,
		PrivatePrimary: false,
		Shared:         false,
		Underlay:       false,
		Supported:      false,
	}
	External = NetworkType{
		Name:           mn.External,
		Private:        false,
		PrivatePrimary: false,
		Shared:         false,
		Underlay:       false,
		Supported:      true,
	}
	Underlay = NetworkType{
		Name:           mn.Underlay,
		Private:        false,
		PrivatePrimary: false,
		Shared:         false,
		Underlay:       true,
		Supported:      true,
	}
	AllNetworkTypes = []NetworkType{PrivatePrimaryUnshared, PrivatePrimaryShared, PrivateSecondaryShared, PrivateSecondaryUnshared, External, Underlay}
)
View Source
var (
	// View Groupname
	ViewGroups = []security.ResourceAccess{
		security.ResourceAccess("k8s_kaas-view"),
		security.ResourceAccess("maas-all-all-view"),
	}

	// Edit Groupname
	EditGroups = []security.ResourceAccess{
		security.ResourceAccess("k8s_kaas-edit"),
		security.ResourceAccess("maas-all-all-edit"),
	}

	// Admin Groupname
	AdminGroups = []security.ResourceAccess{
		security.ResourceAccess("k8s_kaas-admin"),
		security.ResourceAccess("maas-all-all-admin"),
	}

	// Groups that have view permission
	ViewAccess = sec.MergeResourceAccess(ViewGroups, EditGroups, AdminGroups)
	// Groups that have edit permission
	EditAccess = sec.MergeResourceAccess(EditGroups, AdminGroups)
	// Groups that have admin permission
	AdminAccess = AdminGroups
)

These are our supported groups.

View Source
var (
	TopicMachine    = NSQTopic{Name: "machine", PartitionAgnostic: true}
	TopicAllocation = NSQTopic{Name: "allocation", PartitionAgnostic: false}
)
View Source
var DefaultImageExpiration = time.Hour * 24 * 90

DefaultImageExpiration if not specified images will last for about 3 month

View Source
var FirmwareKinds = []string{
	FirmwareBIOS,
	FirmwareBMC,
}

Topics is a list of topics of which the metal-api is a producer. metal-api will make sure these topics exist when it is started.

View Source
var UnknownSize = &Size{
	Base: Base{
		ID:   "unknown",
		Name: "unknown",
	},
}

UnknownSize is the size to use, when someone requires a size we do not know.

Functions

func Conflict

func Conflict(format string, args ...interface{}) error

Conflict creates a new conflict error with a given error message.

func Internal

func Internal(err error, format string, args ...interface{}) error

Internal creates a new Internal error with a given error message and the original error.

func IpTag

func IpTag(key, value string) string

func IsConflict

func IsConflict(e error) bool

IsConflict checks if an error is a conflict error.

func IsInternal

func IsInternal(e error) bool

IsInternal checks if an error is a Internal error.

func IsNotFound

func IsNotFound(e error) bool

IsNotFound checks if an error is a notfound error.

func NotFound

func NotFound(format string, args ...interface{}) error

NotFound creates a new notfound error with a given error message.

Types

type AllocationEvent added in v0.8.1

type AllocationEvent struct {
	MachineID string `json:"old,omitempty"`
}

AllocationEvent is propagated when a machine is allocated.

type BIOS

type BIOS struct {
	Version string `rethinkdb:"version" json:"version"`
	Vendor  string `rethinkdb:"vendor" json:"vendor"`
	Date    string `rethinkdb:"date" json:"date"`
}

BIOS contains machine bios information

type Base

type Base struct {
	ID          string    `rethinkdb:"id,omitempty" json:"id,omitempty"`
	Name        string    `rethinkdb:"name" json:"name"`
	Description string    `rethinkdb:"description" json:"description"`
	Created     time.Time `rethinkdb:"created" json:"created"`
	Changed     time.Time `rethinkdb:"changed" json:"changed"`
}

Base implements common fields for most basic entity types (not all).

func (*Base) GetChanged

func (b *Base) GetChanged() time.Time

GetChanged returns the last changed timestamp of the entity

func (*Base) GetCreated

func (b *Base) GetCreated() time.Time

GetCreated returns the creation timestamp of the entity

func (*Base) GetID

func (b *Base) GetID() string

GetID returns the ID of the entity

func (*Base) SetChanged

func (b *Base) SetChanged(changed time.Time)

SetChanged sets the last changed timestamp of the entity

func (*Base) SetCreated

func (b *Base) SetCreated(created time.Time)

SetCreated sets the creation timestamp of the entity

func (*Base) SetID

func (b *Base) SetID(id string)

SetID sets the ID of the entity

type BlockDevice

type BlockDevice struct {
	Name string `rethinkdb:"name" json:"name"`
	Size uint64 `rethinkdb:"size" json:"size"`
}

BlockDevice information.

type BootConfiguration

type BootConfiguration struct {
	ImageURL    string `rethinkdb:"imageurl" json:"imageurl"`
	KernelURL   string `rethinkdb:"kernelurl" json:"kernelurl"`
	CommandLine string `rethinkdb:"commandline" json:"commandline"`
}

BootConfiguration defines the metal-hammer initrd, kernel and commandline

type ChassisIdentifyLEDState

type ChassisIdentifyLEDState struct {
	Value       LEDState `rethinkdb:"value" json:"value"`
	Description string   `rethinkdb:"description" json:"description"`
}

A ChassisIdentifyLEDState describes the state of a chassis identify LED, i.e. LED-ON/LED-OFF.

type Connection

type Connection struct {
	Nic       Nic    `rethinkdb:"nic" json:"nic"`
	MachineID string `rethinkdb:"machineid" json:"machineid"`
}

Connection between switch port and machine.

type ConnectionMap

type ConnectionMap map[string]Connections

ConnectionMap is an indexed map of connection-lists

func (ConnectionMap) ByNicName added in v0.8.0

func (c ConnectionMap) ByNicName() (map[string]Connection, error)

ByNicName builds a map of nic names to machine connection

type Connections

type Connections []Connection

Connections is a list of connections.

type Constraint

type Constraint struct {
	Type ConstraintType `rethinkdb:"type" json:"type"`
	Min  uint64         `rethinkdb:"min" json:"min"`
	Max  uint64         `rethinkdb:"max" json:"max"`
}

A Constraint describes the hardware constraints for a given size. At the moment we only consider the cpu cores and the memory.

func (*Constraint) Matches

Matches returns true if the given machine hardware is inside the min/max values of the constraint.

type ConstraintMatchingLog

type ConstraintMatchingLog struct {
	Constraint Constraint
	Match      bool
	Log        string
}

A ConstraintMatchingLog is used do return a log message to the caller beside the contraint itself.

type ConstraintType

type ConstraintType string

ConstraintType ...

const (
	CoreConstraint    ConstraintType = "cores"
	MemoryConstraint  ConstraintType = "memory"
	StorageConstraint ConstraintType = "storage"
)

come constraint types

type Disk added in v0.15.0

type Disk struct {
	// Device is the full device path
	Device string `rethinkdb:"device" json:"device"`
	// Partitions to create on this device
	Partitions []DiskPartition `rethinkdb:"partitions" json:"partitions"`
	// WipeOnReinstall, if set to true the whole disk will be erased if reinstall happens
	// during fresh install all disks are wiped
	WipeOnReinstall bool `rethinkdb:"wipeonreinstall" json:"wipeonreinstall"`
}

Disk represents a single block device visible from the OS, required

type DiskPartition added in v0.6.0

type DiskPartition struct {
	// Number of this partition, will be added to partitionprefix
	Number uint8 `rethinkdb:"number" json:"number"`
	// Label to enhance readability
	Label *string `rethinkdb:"label" json:"label"`
	// Size of this partition in mebibytes (MiB)
	// if "0" is given the rest of the device will be used, this requires Number to be the highest in this partition
	Size uint64 `rethinkdb:"size" json:"size"`
	// GPTType defines the GPT partition type
	GPTType *GPTType `rethinkdb:"gpttype" json:"gpttype"`
}

DiskPartition is a single partition on a device, only GPT partition types are supported

type Entity

type Entity interface {
	// GetID returns the entity's id
	GetID() string
	// SetID sets the entity's id
	SetID(id string)
	// GetChanged returns the entity's changed time
	GetChanged() time.Time
	// SetChanged sets the entity's changed time
	SetChanged(changed time.Time)
	// GetCreated sets the entity's creation time
	GetCreated() time.Time
	// SetCreated sets the entity's creation time
	SetCreated(created time.Time)
}

Entity is an interface that allows metal entities to be created and stored into the database with the generic creation and update functions.

type EventType

type EventType string

EventType is the type for event types.

const (
	CREATE  EventType = "create"
	UPDATE  EventType = "update"
	DELETE  EventType = "delete"
	COMMAND EventType = "command"
)

Some enums.

type Filesystem added in v0.15.0

type Filesystem struct {
	// Path defines the mountpoint, if nil, it will not be mounted
	Path *string `rethinkdb:"path" json:"path"`
	// Device where the filesystem is created on, must be the full device path seen by the OS
	Device string `rethinkdb:"device" json:"device"`
	// Format is the type of filesystem should be created
	Format Format `rethinkdb:"format" json:"format"`
	// Label is optional enhances readability
	Label *string `rethinkdb:"label" json:"label"`
	// MountOptions which might be required
	MountOptions []string `rethinkdb:"mountoptions" json:"mountoptions"`
	// CreateOptions during filesystem creation
	CreateOptions []string `rethinkdb:"createoptions" json:"createoptions"`
}

Filesystem defines a single filesystem to be mounted

type FilesystemLayout added in v0.15.0

type FilesystemLayout struct {
	Base
	// Filesystems to create on the server
	Filesystems []Filesystem `rethinkdb:"filesystems" json:"filesystem"`
	// Disks to configure in the server with their partitions
	Disks []Disk `rethinkdb:"disks" json:"disks"`
	// Raid if not empty, create raid arrays out of the individual disks, to place filesystems onto
	Raid []Raid `rethinkdb:"raid" json:"raid"`
	// VolumeGroups to create
	VolumeGroups []VolumeGroup `rethinkdb:"volumegroups" json:"volumegroups"`
	// LogicalVolumes to create on top of VolumeGroups
	LogicalVolumes LogicalVolumes `rethinkdb:"logicalvolumes" json:"logicalvolumes"`
	// Constraints which must match to select this Layout
	Constraints FilesystemLayoutConstraints `rethinkdb:"constraints" json:"constraints"`
}

FilesystemLayout to be created on the given machine

func (*FilesystemLayout) IsReinstallable added in v0.15.0

func (fl *FilesystemLayout) IsReinstallable() bool

IsReinstallable returns true if at least one disk configures has WipeOnReInstall set, otherwise false

func (*FilesystemLayout) Matches added in v0.15.0

func (fl *FilesystemLayout) Matches(hardware MachineHardware) error

Matches the specific FilesystemLayout against the selected Hardware

func (FilesystemLayout) Validate added in v0.15.0

func (f FilesystemLayout) Validate() error

Validate a existing FilesystemLayout

type FilesystemLayoutConstraints added in v0.15.0

type FilesystemLayoutConstraints struct {
	// Sizes defines the list of sizes this layout applies to
	Sizes []string `rethinkdb:"sizes" json:"sizes"`
	// Images defines a map from os to versionconstraint
	// the combination of os and versionconstraint per size must be conflict free over all filesystemlayouts
	Images map[string]string `rethinkdb:"images" json:"images"`
}

type FilesystemLayouts added in v0.15.0

type FilesystemLayouts []FilesystemLayout

FilesystemLayouts is a slice of FilesystemLayout

func (FilesystemLayouts) From added in v0.15.0

func (fls FilesystemLayouts) From(size, image string) (*FilesystemLayout, error)

From will pick a filesystemlayout from all filesystemlayouts which matches given size and image

func (FilesystemLayouts) Validate added in v0.15.0

func (fls FilesystemLayouts) Validate() error

Validate ensures that for all Filesystemlayouts not more than one constraint matches the same size and image constraint

type FirmwareKind added in v0.18.6

type FirmwareKind = string
const (
	FirmwareBIOS FirmwareKind = "bios"
	FirmwareBMC  FirmwareKind = "bmc"
)

type FirmwareUpdate added in v0.18.6

type FirmwareUpdate struct {
	Kind FirmwareKind `json:"kind"`
	URL  string       `json:"url"`
}

type Format added in v0.15.0

type Format string

func ToFormat added in v0.15.0

func ToFormat(format string) (*Format, error)

type Fru

type Fru struct {
	ChassisPartNumber   string `rethinkdb:"chassis_part_number" json:"chassis_part_number"`
	ChassisPartSerial   string `rethinkdb:"chassis_part_serial" json:"chassis_part_serial"`
	BoardMfg            string `rethinkdb:"board_mfg" json:"board_mfg"`
	BoardMfgSerial      string `rethinkdb:"board_mfg_serial" json:"board_mfg_serial"`
	BoardPartNumber     string `rethinkdb:"board_part_number" json:"board_part_number"`
	ProductManufacturer string `rethinkdb:"product_manufacturer" json:"product_manufacturer"`
	ProductPartNumber   string `rethinkdb:"product_part_number" json:"product_part_number"`
	ProductSerial       string `rethinkdb:"product_serial" json:"product_serial"`
}

Fru (Field Replaceable Unit) data

type GPTType added in v0.15.0

type GPTType string

func ToGPTType added in v0.15.0

func ToGPTType(gptType string) (*GPTType, error)

type IP

type IP struct {
	IPAddress string `rethinkdb:"id" json:"id"`
	// AllocationID will be randomly generated during IP creation and helps identifying the point in time
	// when an IP was created. This is not the primary key!
	// This field can help to distinguish whether an IP address was re-acquired or
	// if it is still the same ip address as before.
	AllocationUUID   string    `rethinkdb:"allocationuuid" json:"allocationuuid"`
	ParentPrefixCidr string    `rethinkdb:"prefix" json:"prefix"`
	Name             string    `rethinkdb:"name" json:"name"`
	Description      string    `rethinkdb:"description" json:"description"`
	ProjectID        string    `rethinkdb:"projectid" json:"projectid"`
	NetworkID        string    `rethinkdb:"networkid" json:"networkid"`
	Type             IPType    `rethinkdb:"type" json:"type"`
	Tags             []string  `rethinkdb:"tags" json:"tags"`
	Created          time.Time `rethinkdb:"created" json:"created"`
	Changed          time.Time `rethinkdb:"changed" json:"changed"`
}

IP of a machine/firewall.

func (*IP) AddMachineId

func (ip *IP) AddMachineId(id string)

func (*IP) GetChanged

func (ip *IP) GetChanged() time.Time

GetChanged returns the last changed timestamp of the entity

func (*IP) GetCreated

func (ip *IP) GetCreated() time.Time

GetCreated returns the creation timestamp of the entity

func (*IP) GetID

func (ip *IP) GetID() string

GetID returns the ID of the entity

func (*IP) GetMachineIds

func (ip *IP) GetMachineIds() []string

func (*IP) GetScope

func (ip *IP) GetScope() IPScope

GetScope determines the scope of an ip address

func (*IP) HasMachineId

func (ip *IP) HasMachineId(id string) bool

func (*IP) RemoveMachineId

func (ip *IP) RemoveMachineId(id string)

func (*IP) SetChanged

func (ip *IP) SetChanged(changed time.Time)

SetChanged sets the last changed timestamp of the entity

func (*IP) SetCreated

func (ip *IP) SetCreated(created time.Time)

SetCreated sets the creation timestamp of the entity

func (*IP) SetID

func (ip *IP) SetID(id string)

SetID sets the ID of the entity

type IPMI

type IPMI struct {
	// Address is host:port of the connection to the ipmi BMC, host can be either a ip address or a hostname
	Address     string       `rethinkdb:"address" json:"address"`
	MacAddress  string       `rethinkdb:"mac" json:"mac"`
	User        string       `rethinkdb:"user" json:"user"`
	Password    string       `rethinkdb:"password" json:"password"`
	Interface   string       `rethinkdb:"interface" json:"interface"`
	Fru         Fru          `rethinkdb:"fru" json:"fru"`
	BMCVersion  string       `rethinkdb:"bmcversion" json:"bmcversion"`
	PowerState  string       `rethinkdb:"powerstate" json:"powerstate"`
	PowerMetric *PowerMetric `rethinkdb:"powermetric" json:"powermetric"`
}

IPMI connection data

type IPScope

type IPScope string

IPScope is the scope of an ip.

type IPType

type IPType string

IPType is the type of an ip.

type IPs

type IPs []IP

func (IPs) ByProjectID

func (l IPs) ByProjectID() IPsMap

type IPsMap

type IPsMap map[string]IPs

type Image

type Image struct {
	Base
	URL      string                    `rethinkdb:"url" json:"url"`
	Features map[ImageFeatureType]bool `rethinkdb:"features" json:"features"`
	// OS is parsed from id and is the first part, specifies operating system derivate, internal usage only
	OS string `rethinkdb:"os" json:"os"`
	// Version is parsed from id and is the second part, specifies operating system version, internal usage only
	Version string `rethinkdb:"version" json:"version"`
	// ExpirationDate defines the time in the future, when this image is not considered for machine allocations anymore
	ExpirationDate time.Time `rethinkdb:"expirationDate" json:"expirationDate"`
	// Classification defines the state of a version (preview, supported, deprecated)
	// only informational, no action depending on the classification done
	Classification VersionClassification `rethinkdb:"classification" json:"classification"`
}

An Image describes an image which could be used for provisioning.

func (*Image) HasFeature

func (i *Image) HasFeature(feature ImageFeatureType) bool

HasFeature returns true if this image has given feature enabled, otherwise false.

func (*Image) ImageFeatureString

func (i *Image) ImageFeatureString() string

ImageFeatureString returns the features of an image as a string.

type ImageFeatureType

type ImageFeatureType string

ImageFeatureType specifies the features of a images

const (
	// ImageFeatureFirewall from this image only a firewall can created
	ImageFeatureFirewall ImageFeatureType = "firewall"
	// ImageFeatureMachine from this image only a machine can created
	ImageFeatureMachine ImageFeatureType = "machine"
)

func ImageFeatureTypeFrom

func ImageFeatureTypeFrom(name string) (ImageFeatureType, error)

ImageFeatureTypeFrom a given name to a ImageFeatureType or error.

type ImageMap

type ImageMap map[string]Image

ImageMap is an indexed map for images.

type Images

type Images []Image

Images is a collection of images.

func (Images) ByID

func (ii Images) ByID() ImageMap

ByID creates an indexed map from an image collection.

type LEDState

type LEDState string

LEDState is the state of the LED of the Machine

const (
	// LEDStateOn LED is on
	LEDStateOn LEDState = "LED-ON"
	// LEDStateOff LED is off
	LEDStateOff LEDState = "LED-OFF"
)

func LEDStateFrom

func LEDStateFrom(name string) (LEDState, error)

LEDStateFrom converts an LEDState string to the corresponding type

type LVMType added in v0.15.0

type LVMType string

func ToLVMType added in v0.15.0

func ToLVMType(lvmtype string) (*LVMType, error)

type LogicalVolume added in v0.15.0

type LogicalVolume struct {
	// Name the name of the logical volume, without /dev prefix, will be accessible at /dev/vgname/lvname
	Name string `rethinkdb:"name" json:"name"`
	// VolumeGroup the name of the volumegroup
	VolumeGroup string `rethinkdb:"volumegroup" json:"volumegroup"`
	// Size of this LV in mebibytes (MiB), if zero all remaining space in the vg will be used.
	Size uint64 `rethinkdb:"size" json:"size"`
	// LVMType can be either linear, striped or raid1
	LVMType LVMType `rethinkdb:"lvmtype" json:"lvmtype"`
}

LogicalVolume is a block devices created with lvm on top of a volumegroup

type LogicalVolumes added in v0.16.0

type LogicalVolumes []LogicalVolume

LogicalVolumes is a slice of LogicalVolume

type MState

type MState string

A MState is an enum which indicates the state of a machine

const (
	// AvailableState describes a machine state where a machine is available for an allocation
	AvailableState MState = ""
	// ReservedState describes a machine state where a machine is not being considered for random allocation
	ReservedState MState = "RESERVED"
	// LockedState describes a machine state where a machine cannot be deleted or allocated anymore
	LockedState MState = "LOCKED"
)

func MachineStateFrom

func MachineStateFrom(name string) (MState, error)

MachineStateFrom converts a machineState string to the type

type MacAddress

type MacAddress string

A MacAddress is the type for mac adresses. When using a custom type, we cannot use strings directly.

type Machine

type Machine struct {
	Base
	Allocation   *MachineAllocation      `rethinkdb:"allocation" json:"allocation"`
	PartitionID  string                  `rethinkdb:"partitionid" json:"partitionid"`
	SizeID       string                  `rethinkdb:"sizeid" json:"sizeid"`
	RackID       string                  `rethinkdb:"rackid" json:"rackid"`
	Waiting      bool                    `rethinkdb:"waiting" json:"waiting"`
	PreAllocated bool                    `rethinkdb:"preallocated" json:"preallocated"`
	Hardware     MachineHardware         `rethinkdb:"hardware" json:"hardware"`
	State        MachineState            `rethinkdb:"state" json:"state"`
	LEDState     ChassisIdentifyLEDState `rethinkdb:"ledstate" json:"ledstate"`
	Tags         []string                `rethinkdb:"tags" json:"tags"`
	IPMI         IPMI                    `rethinkdb:"ipmi" json:"ipmi"`
	BIOS         BIOS                    `rethinkdb:"bios" json:"bios"`
}

A Machine is a piece of metal which is under the control of our system. It registers itself and can be allocated or freed. If the machine is allocated, the substructure Allocation will be filled. Any unallocated (free) machine won't have such values.

func (*Machine) HasMAC

func (m *Machine) HasMAC(mac string) bool

HasMAC returns true if this machine has the given MAC.

func (*Machine) IsFirewall

func (m *Machine) IsFirewall() bool

IsFirewall returns true if this machine is a firewall machine.

type MachineAllocation

type MachineAllocation struct {
	Creator          string            `rethinkdb:"creator" json:"creator"`
	Created          time.Time         `rethinkdb:"created" json:"created"`
	Name             string            `rethinkdb:"name" json:"name"`
	Description      string            `rethinkdb:"description" json:"description"`
	Project          string            `rethinkdb:"project" json:"project"`
	ImageID          string            `rethinkdb:"imageid" json:"imageid"`
	FilesystemLayout *FilesystemLayout `rethinkdb:"filesystemlayout" json:"filesystemlayout"`
	MachineNetworks  []*MachineNetwork `rethinkdb:"networks" json:"networks"`
	Hostname         string            `rethinkdb:"hostname" json:"hostname"`
	SSHPubKeys       []string          `rethinkdb:"sshPubKeys" json:"sshPubKeys"`
	UserData         string            `rethinkdb:"userdata" json:"userdata"`
	ConsolePassword  string            `rethinkdb:"console_password" json:"console_password"`
	Succeeded        bool              `rethinkdb:"succeeded" json:"succeeded"`
	Reinstall        bool              `rethinkdb:"reinstall" json:"reinstall"`
	MachineSetup     *MachineSetup     `rethinkdb:"setup" json:"setup"`
	Role             Role              `rethinkdb:"role" json:"role"`
	VPN              *MachineVPN       `rethinkdb:"vpn" json:"vpn"`
}

A MachineAllocation stores the data which are only present for allocated machines.

type MachineCommand

type MachineCommand string

A MachineCommand is an alias of a string

const (
	MachineOnCmd             MachineCommand = "ON"
	MachineOffCmd            MachineCommand = "OFF"
	MachineResetCmd          MachineCommand = "RESET"
	MachineCycleCmd          MachineCommand = "CYCLE"
	MachineBiosCmd           MachineCommand = "BIOS"
	MachineDiskCmd           MachineCommand = "DISK"
	MachinePxeCmd            MachineCommand = "PXE"
	MachineReinstallCmd      MachineCommand = "REINSTALL"
	ChassisIdentifyLEDOnCmd  MachineCommand = "LED-ON"
	ChassisIdentifyLEDOffCmd MachineCommand = "LED-OFF"
	UpdateFirmwareCmd        MachineCommand = "UPDATE-FIRMWARE"
)

our supported machines commands.

type MachineEvent

type MachineEvent struct {
	Type         EventType           `json:"type,omitempty"`
	OldMachineID string              `json:"old,omitempty"`
	NewMachineID string              `json:"new,omitempty"`
	Cmd          *MachineExecCommand `json:"cmd,omitempty"`
}

MachineEvent is propagated when a machine is create/updated/deleted.

type MachineExecCommand

type MachineExecCommand struct {
	TargetMachineID string          `json:"target,omitempty"`
	Command         MachineCommand  `json:"cmd,omitempty"`
	IPMI            *IPMI           `json:"ipmi,omitempty"`
	FirmwareUpdate  *FirmwareUpdate `json:"firmwareupdate,omitempty"`
}

A MachineExecCommand can be sent via a MachineEvent to execute the command against the specific machine. The specified command should be executed against the given target machine. The parameters is an optional array of strings which are implementation specific and dependent of the command.

type MachineHardware

type MachineHardware struct {
	Memory   uint64        `rethinkdb:"memory" json:"memory"`
	CPUCores int           `rethinkdb:"cpu_cores" json:"cpu_cores"`
	Nics     Nics          `rethinkdb:"network_interfaces" json:"network_interfaces"`
	Disks    []BlockDevice `rethinkdb:"block_devices" json:"block_devices"`
}

MachineHardware stores the data which is collected by our system on the hardware when it registers itself.

func (*MachineHardware) DiskCapacity

func (hw *MachineHardware) DiskCapacity() uint64

DiskCapacity calculates the capacity of all disks.

func (*MachineHardware) ReadableSpec

func (hw *MachineHardware) ReadableSpec() string

ReadableSpec returns a human readable string for the hardware.

type MachineLiveliness

type MachineLiveliness string

MachineLiveliness indicates the liveliness of a machine

const (
	MachineLivelinessAlive   MachineLiveliness = "Alive"
	MachineLivelinessDead    MachineLiveliness = "Dead"
	MachineLivelinessUnknown MachineLiveliness = "Unknown"
	MachineDeadAfter         time.Duration     = 5 * time.Minute
	MachineResurrectAfter    time.Duration     = time.Hour
)

The enums for the machine liveliness states.

func (MachineLiveliness) Is

func (l MachineLiveliness) Is(liveliness string) bool

Is return true if given liveliness is equal to specific Liveliness

type MachineNetwork

type MachineNetwork struct {
	NetworkID           string   `rethinkdb:"networkid" json:"networkid"`
	Prefixes            []string `rethinkdb:"prefixes" json:"prefixes"`
	IPs                 []string `rethinkdb:"ips" json:"ips"`
	DestinationPrefixes []string `rethinkdb:"destinationprefixes" json:"destinationprefixes"`
	Vrf                 uint     `rethinkdb:"vrf" json:"vrf"`
	PrivatePrimary      bool     `rethinkdb:"privateprimary" json:"privateprimary"`
	Private             bool     `rethinkdb:"private" json:"private"`
	ASN                 uint32   `rethinkdb:"asn" json:"asn"`
	Nat                 bool     `rethinkdb:"nat" json:"nat"`
	Underlay            bool     `rethinkdb:"underlay" json:"underlay"`
	Shared              bool     `rethinkdb:"shared" json:"shared"`
}

MachineNetwork stores the Network details of the machine

func (*MachineNetwork) ContainsIP

func (n *MachineNetwork) ContainsIP(ip string) bool

ContainsIP checks whether the given ip is included in the networks prefixes

func (*MachineNetwork) Is added in v0.10.0

func (mn *MachineNetwork) Is(n NetworkType) bool

Is checks whether the machine network has the given type

func (*MachineNetwork) NetworkType added in v0.10.0

func (mn *MachineNetwork) NetworkType() (*NetworkType, error)

NetworkType determines the network type based on the flags stored in the db entity.

type MachineSetup added in v0.6.0

type MachineSetup struct {
	ImageID      string `rethinkdb:"imageid" json:"imageid"`
	PrimaryDisk  string `rethinkdb:"primarydisk" json:"primarydisk"`
	OSPartition  string `rethinkdb:"ospartition" json:"ospartition"`
	Initrd       string `rethinkdb:"initrd" json:"initrd"`
	Cmdline      string `rethinkdb:"cmdline" json:"cmdline"`
	Kernel       string `rethinkdb:"kernel" json:"kernel"`
	BootloaderID string `rethinkdb:"bootloaderid" json:"bootloaderid"`
}

A MachineSetup stores the data used for machine reinstallations.

type MachineState

type MachineState struct {
	Value              MState `rethinkdb:"value" json:"value"`
	Description        string `rethinkdb:"description" json:"description"`
	Issuer             string `rethinkdb:"issuer" json:"issuer,omitempty"`
	MetalHammerVersion string `rethinkdb:"metal_hammer_version" json:"metal_hammer_version"`
}

A MachineState describes the state of a machine. If the Value is AvailableState, the machine will be available for allocation. In all other cases the allocation must explicitly point to this machine.

type MachineVPN added in v0.20.0

type MachineVPN struct {
	ControlPlaneAddress string `rethinkdb:"address" json:"address"`
	AuthKey             string `rethinkdb:"auth_key" json:"auth_key"`
	Connected           bool   `rethinkdb:"connected" json:"connected"`
}

type Machines

type Machines []Machine

Machines is a slice of Machine

func (Machines) ByProjectID

func (ms Machines) ByProjectID() map[string]Machines

ByProjectID creates a map of machines with the project id as the index.

type NSQTopic

type NSQTopic struct {
	Name              string
	PartitionAgnostic bool
}

NSQTopic .

func (NSQTopic) GetFQN

func (t NSQTopic) GetFQN(partitionID string) string

GetFQN gets the fully qualified name of a NSQTopic

type Network

type Network struct {
	Base
	Prefixes            Prefixes          `rethinkdb:"prefixes" json:"prefixes"`
	DestinationPrefixes Prefixes          `rethinkdb:"destinationprefixes" json:"destinationprefixes"`
	PartitionID         string            `rethinkdb:"partitionid" json:"partitionid"`
	ProjectID           string            `rethinkdb:"projectid" json:"projectid"`
	ParentNetworkID     string            `rethinkdb:"parentnetworkid" json:"parentnetworkid"`
	Vrf                 uint              `rethinkdb:"vrf" json:"vrf"`
	PrivateSuper        bool              `rethinkdb:"privatesuper" json:"privatesuper"`
	Nat                 bool              `rethinkdb:"nat" json:"nat"`
	Underlay            bool              `rethinkdb:"underlay" json:"underlay"`
	Shared              bool              `rethinkdb:"shared" json:"shared"`
	Labels              map[string]string `rethinkdb:"labels" json:"labels"`
}

Network is a network in a metal as a service infrastructure. TODO specify rethinkdb restrictions.

func (*Network) FindPrefix

func (n *Network) FindPrefix(cidr string) *Prefix

FindPrefix returns the prefix by cidr if contained in this network, nil otherwise

func (*Network) SubstractPrefixes

func (n *Network) SubstractPrefixes(prefixes ...Prefix) []Prefix

SubstractPrefixes returns the prefixes of the network minus the prefixes passed in the arguments

type NetworkMap

type NetworkMap map[string]Network

NetworkMap is an indexed map of networks

type NetworkType added in v0.10.0

type NetworkType struct {
	Name           string `json:"name,omitempty"`
	Private        bool   `json:"private,omitempty"`
	PrivatePrimary bool   `json:"private_primary,omitempty"`
	Shared         bool   `json:"shared,omitempty"`
	Underlay       bool   `json:"underlay,omitempty"`
	Supported      bool   `json:"-"`
}

NetworkType represents the type of a network

func (NetworkType) String added in v0.10.0

func (n NetworkType) String() string

type NetworkUsage

type NetworkUsage struct {
	AvailableIPs      uint64 `json:"available_ips" description:"the total available IPs" readonly:"true"`
	UsedIPs           uint64 `json:"used_ips" description:"the total used IPs" readonly:"true"`
	AvailablePrefixes uint64 `json:"available_prefixes" description:"the total available Prefixes" readonly:"true"`
	UsedPrefixes      uint64 `json:"used_prefixes" description:"the total used Prefixes" readonly:"true"`
}

NetworkUsage contains usage information of a network

type Networks

type Networks []Network

Networks is a list of networks.

func (Networks) ByID

func (nws Networks) ByID() NetworkMap

ByID creates an indexed map of partitions whre the id is the index.

type Nic

type Nic struct {
	MacAddress MacAddress `rethinkdb:"macAddress" json:"macAddress"`
	Name       string     `rethinkdb:"name" json:"name"`
	Vrf        string     `rethinkdb:"vrf" json:"vrf"`
	Neighbors  Nics       `rethinkdb:"neighbors" json:"neighbors"`
}

Nic information.

type NicMap

type NicMap map[MacAddress]*Nic

type Nics

type Nics []Nic

Nics is a list of nics.

func (Nics) ByMac

func (nics Nics) ByMac() NicMap

ByMac creates a indexed map from a nic list.

func (Nics) ByName added in v0.8.0

func (nics Nics) ByName() map[string]*Nic

ByName creates a indexed map from a nic list.

type Partition

type Partition struct {
	Base
	BootConfiguration          BootConfiguration `rethinkdb:"bootconfig" json:"bootconfig"`
	MgmtServiceAddress         string            `rethinkdb:"mgmtserviceaddr" json:"mgmtserviceaddr"`
	PrivateNetworkPrefixLength uint8             `rethinkdb:"privatenetworkprefixlength" json:"privatenetworkprefixlength"`
}

A Partition represents a location.

type PartitionMap

type PartitionMap map[string]Partition

PartitionMap is an indexed map of partitions

type Partitions

type Partitions []Partition

Partitions is a list of partitions.

func (Partitions) ByID

func (sz Partitions) ByID() PartitionMap

ByID creates an indexed map of partitions whre the id is the index.

type PowerMetric added in v0.21.5

type PowerMetric struct {
	// AverageConsumedWatts shall represent the
	// average power level that occurred averaged over the last IntervalInMin
	// minutes.
	AverageConsumedWatts float32 `rethinkdb:"averageconsumedwatts" json:"averageconsumedwatts"`
	// IntervalInMin shall represent the time
	// interval (or window), in minutes, in which the PowerMetrics properties
	// are measured over.
	// Should be an integer, but some Dell implementations return as a float.
	IntervalInMin float32 `rethinkdb:"intervalinmin" json:"intervalinmin"`
	// MaxConsumedWatts shall represent the
	// maximum power level in watts that occurred within the last
	// IntervalInMin minutes.
	MaxConsumedWatts float32 `rethinkdb:"maxconsumedwatts" json:"maxconsumedwatts"`
	// MinConsumedWatts shall represent the
	// minimum power level in watts that occurred within the last
	// IntervalInMin minutes.
	MinConsumedWatts float32 `rethinkdb:"minconsumedwatts" json:"minconsumedwatts"`
}

type Prefix

type Prefix struct {
	IP     string `rethinkdb:"ip" json:"ip"`
	Length string `rethinkdb:"length" json:"length"`
}

Prefix is a ip with mask, either ipv4/ipv6

func NewPrefixFromCIDR

func NewPrefixFromCIDR(cidr string) (*Prefix, error)

NewPrefixFromCIDR returns a new prefix from a given cidr.

func (*Prefix) Equals

func (p *Prefix) Equals(other *Prefix) bool

Equals returns true when prefixes have the same cidr.

func (*Prefix) String

func (p *Prefix) String() string

String implements the Stringer interface

type Prefixes

type Prefixes []Prefix

Prefixes is an array of prefixes

func (Prefixes) String

func (p Prefixes) String() []string

type ProvisioningEvent

type ProvisioningEvent struct {
	Time    time.Time             `rethinkdb:"time" json:"time"`
	Event   ProvisioningEventType `rethinkdb:"event" json:"event"`
	Message string                `rethinkdb:"message" json:"message"`
}

ProvisioningEvent is an event emitted by a machine during the provisioning sequence

type ProvisioningEventContainer

type ProvisioningEventContainer struct {
	Base
	Liveliness           MachineLiveliness  `rethinkdb:"liveliness" json:"liveliness"`
	Events               ProvisioningEvents `rethinkdb:"events" json:"events"`
	LastEventTime        *time.Time         `rethinkdb:"last_event_time" json:"last_event_time"`
	LastErrorEvent       *ProvisioningEvent `rethinkdb:"last_error_event" json:"last_error_event"`
	CrashLoop            bool               `rethinkdb:"crash_loop" json:"crash_loop"`
	FailedMachineReclaim bool               `rethinkdb:"failed_machine_reclaim" json:"failed_machine_reclaim"`
}

ProvisioningEventContainer stores the provisioning events of a machine

func (*ProvisioningEventContainer) TrimEvents

func (p *ProvisioningEventContainer) TrimEvents(maxCount int)

TrimEvents trim the events to maxCount

func (*ProvisioningEventContainer) Validate added in v0.19.0

func (c *ProvisioningEventContainer) Validate() error

type ProvisioningEventContainerMap

type ProvisioningEventContainerMap map[string]ProvisioningEventContainer

ProvisioningEventContainerMap is an indexed map of machine event containers.

type ProvisioningEventContainers

type ProvisioningEventContainers []ProvisioningEventContainer

ProvisioningEventContainers is a list of machine provisioning event containers.

func (ProvisioningEventContainers) ByID

ByID creates a map of event provisioning containers with the id as the index.

type ProvisioningEventType

type ProvisioningEventType string

ProvisioningEventType indicates an event emitted by a machine during the provisioning sequence

const (
	ProvisioningEventAlive            ProvisioningEventType = "Alive"
	ProvisioningEventCrashed          ProvisioningEventType = "Crashed"
	ProvisioningEventPXEBooting       ProvisioningEventType = "PXE Booting"
	ProvisioningEventPlannedReboot    ProvisioningEventType = "Planned Reboot"
	ProvisioningEventPreparing        ProvisioningEventType = "Preparing"
	ProvisioningEventRegistering      ProvisioningEventType = "Registering"
	ProvisioningEventWaiting          ProvisioningEventType = "Waiting"
	ProvisioningEventInstalling       ProvisioningEventType = "Installing"
	ProvisioningEventBootingNewKernel ProvisioningEventType = "Booting New Kernel"
	ProvisioningEventPhonedHome       ProvisioningEventType = "Phoned Home"
	ProvisioningEventMachineReclaim   ProvisioningEventType = "Machine Reclaim"
)

The enums for the machine provisioning events.

func (ProvisioningEventType) Is

func (p ProvisioningEventType) Is(event string) bool

Is return true if given event is equal to specific EventType

func (ProvisioningEventType) String added in v0.19.0

func (t ProvisioningEventType) String() string

type ProvisioningEvents

type ProvisioningEvents []ProvisioningEvent

ProvisioningEvents is just a list of ProvisioningEvents

type Raid added in v0.15.0

type Raid struct {
	// ArrayName of the raid device, most often this will be /dev/md0 and so forth
	ArrayName string `rethinkdb:"arrayname" json:"arrayname"`
	// Devices the devices to form a raid device
	Devices []string `rethinkdb:"devices" json:"devices"`
	// Level the raidlevel to use, can be one of 0,1
	Level RaidLevel `rethinkdb:"raidlevel" json:"raidlevel"`
	// CreateOptions required during raid creation, example: --metadata=1.0 for uefi boot partition
	CreateOptions []string `rethinkdb:"createoptions" json:"createoptions"`
	// Spares defaults to 0
	Spares int `rethinkdb:"spares" json:"spares"`
}

Raid is optional, if given the devices must match.

type RaidLevel added in v0.15.0

type RaidLevel string

func ToRaidLevel added in v0.15.0

func ToRaidLevel(level string) (*RaidLevel, error)

type Role added in v0.15.4

type Role string

Role describes the role of a machine.

var (
	// RoleMachine is a role that indicates the allocated machine acts as a machine
	RoleMachine Role = "machine"
	// RoleFirewall is a role that indicates the allocated machine acts as a firewall
	RoleFirewall Role = "firewall"
)

type Size

type Size struct {
	Base
	Constraints []Constraint `rethinkdb:"constraints" json:"constraints"`
}

A Size represents a supported machine size.

func (*Size) Overlaps added in v0.11.4

func (s *Size) Overlaps(ss *Sizes) *Size

Overlaps returns nil if Size does not overlap with any other size, otherwise returs overlapping Size

type SizeImageConstraint added in v0.16.3

type SizeImageConstraint struct {
	Base
	// Images a map from imageID to semver compatible matcher string
	// example:
	// images:
	//    ubuntu: ">= 20.04.20211011"
	//    debian: ">= 10.0.20210101"
	Images map[string]string `rethinkdb:"images" json:"images"`
}

SizeImageConstraint expresses optional restrictions for specific size to image combinations this might be required if the support for a specific hardware in a given size is only supported with a newer version of the image.

If the size in question is not found, no restrictions apply. If the image in question is not found, no restrictions apply as well. If the image in question is found, but does not match the given expression, machine creation must be forbidden.

func (*SizeImageConstraint) Matches added in v0.16.3

func (sc *SizeImageConstraint) Matches(size Size, image Image) error

func (*SizeImageConstraint) Validate added in v0.16.3

func (sc *SizeImageConstraint) Validate() error

type SizeImageConstraints added in v0.16.3

type SizeImageConstraints []SizeImageConstraint

SizeImageConstraints is a slice of ImageConstraint

func (*SizeImageConstraints) Matches added in v0.16.3

func (scs *SizeImageConstraints) Matches(size Size, image Image) error

func (*SizeImageConstraints) Validate added in v0.16.3

func (scs *SizeImageConstraints) Validate() error

type SizeMap

type SizeMap map[string]Size

SizeMap is an indexed map of sizes.

type SizeMatchingLog

type SizeMatchingLog struct {
	Name        string
	Log         string
	Match       bool
	Constraints []ConstraintMatchingLog
}

A SizeMatchingLog returns information about a list of constraints.

type Sizes

type Sizes []Size

Sizes is a list of sizes.

func (Sizes) ByID

func (sz Sizes) ByID() SizeMap

ByID creates a map of sizes with the id as the index.

func (Sizes) FromHardware

func (sz Sizes) FromHardware(hardware MachineHardware) (*Size, []*SizeMatchingLog, error)

FromHardware searches a Size for given hardware specs. It will search for a size where the constraints matches the given hardware.

type Switch

type Switch struct {
	Base
	Nics               Nics          `rethinkdb:"network_interfaces" json:"network_interfaces"`
	MachineConnections ConnectionMap `rethinkdb:"machineconnections" json:"machineconnections"`
	PartitionID        string        `rethinkdb:"partitionid" json:"partitionid"`
	RackID             string        `rethinkdb:"rackid" json:"rackid"`
	Mode               SwitchMode    `rethinkdb:"mode" json:"mode"`
	LastSync           *SwitchSync   `rethinkdb:"last_sync" json:"last_sync"`
	LastSyncError      *SwitchSync   `rethinkdb:"last_sync_error" json:"last_sync_error"`
}

Switch have to register at the api. As metal-core is a stateless application running on a switch, the api needs persist all the information such that the core can create or restore a its entire switch configuration.

func (*Switch) ConnectMachine

func (s *Switch) ConnectMachine(machine *Machine) int

ConnectMachine iterates over all switch nics and machine nic neighbor to find existing wire connections. Implementation is very inefficient, will also find all connections, which should not happen in a real environment.

func (*Switch) SetVrfOfMachine added in v0.18.0

func (s *Switch) SetVrfOfMachine(m *Machine, vrf string)

SetVrfOfMachine set port on switch where machine is connected to given vrf

type SwitchEvent

type SwitchEvent struct {
	Type     EventType `json:"type"`
	Machine  Machine   `json:"machine"`
	Switches []Switch  `json:"switches"`
}

SwitchEvent is propagated when a switch needs to update its configuration.

type SwitchMode added in v0.8.0

type SwitchMode string

A SwitchMode is an enum which indicates the mode of a switch

const (
	SwitchOperational SwitchMode = "operational"
	SwitchReplace     SwitchMode = "replace"
)

The enums for the switch modes.

func SwitchModeFrom added in v0.8.0

func SwitchModeFrom(name string) SwitchMode

SwitchModeFrom converts a switch mode string to the type

type SwitchSync added in v0.7.1

type SwitchSync struct {
	Time     time.Time     `rethinkdb:"time" json:"time"`
	Duration time.Duration `rethinkdb:"duration" json:"duration"`
	Error    *string       `rethinkdb:"error" json:"error"`
}

SwitchSync contains information about the last synchronization of the state held in the metal-api to a switch.

type VersionClassification added in v0.7.0

type VersionClassification string

VersionClassification is the logical state of a version

const (
	// ClassificationPreview indicates that a version has recently been added and not promoted to "Supported" yet.
	// ClassificationPreview versions will not be considered for automatic OperatingSystem patch version updates.
	ClassificationPreview VersionClassification = "preview"
	// ClassificationSupported indicates that a patch version is the default version for the particular minor version.
	// There is always exactly one supported OperatingSystem patch version for every still maintained OperatingSystem minor version.
	// Supported versions are eligible for the automated OperatingSystem patch version update machines.
	ClassificationSupported VersionClassification = "supported"
	// ClassificationDeprecated indicates that a patch version should not be used anymore, should be updated to a new version
	// and will eventually expire.
	// Every version that is neither in preview nor supported is deprecated.
	// All patch versions of not supported minor versions are deprecated.
	ClassificationDeprecated VersionClassification = "deprecated"
)

func VersionClassificationFrom added in v0.7.0

func VersionClassificationFrom(classification string) (VersionClassification, error)

VersionClassificationFrom create a VersionClassification from string

type VolumeGroup added in v0.15.0

type VolumeGroup struct {
	// Name of the volumegroup without the /dev prefix
	Name string `rethinkdb:"name" json:"name"`
	// Devices the devices to form a volumegroup device
	Devices []string `rethinkdb:"devices" json:"devices"`
	// Tags to attach to the volumegroup
	Tags []string `rethinkdb:"tags" json:"tags"`
}

VolumeGroup is optional, if given the devices must match.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL