Merge ~cgrabowski/maas:rack_spike_power_drivers into maas:rack_region_exploration

[Christian Grabowski]

add fixes based on tcpdump results

add power on / off via IPMI

ipmi requests

define interfaces for power drivers

[MAAS Lander (maas-lander)]

UNIT TESTS
-b rack_spike_power_drivers lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 69f139c38789997c1e8f7f9dd3e580286328bc36

review: Approve

[Alexsander de Souza (alexsander-souza)]

LGTM

review: Approve

diff --git a/src/rackd_spike/internal/drivers/ip_extractor.go b/src/rackd_spike/internal/drivers/ip_extractor.go
new file mode 100644
index 0000000..8be4858
--- /dev/null
+++ b/src/rackd_spike/internal/drivers/ip_extractor.go
@@ -0,0 +1,20 @@
+package drivers
+
+import "regexp"
+
+var (
+	IPExtractorIdentity = regexp.MustCompile("^(?P<address>.+?)$")
+	IPExtractorURL      = regexp.MustCompile(`(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}`)
+)
+
+type IPExtractor struct {
+	Field   string
+	Pattern *regexp.Regexp
+}
+
+func NewIPExtractor(fieldName string, pattern *regexp.Regexp) IPExtractor {
+	return IPExtractor{
+		Field:   fieldName,
+		Pattern: pattern,
+	}
+}
diff --git a/src/rackd_spike/internal/drivers/power/driver.go b/src/rackd_spike/internal/drivers/power/driver.go
new file mode 100644
index 0000000..0764268
--- /dev/null
+++ b/src/rackd_spike/internal/drivers/power/driver.go
@@ -0,0 +1,194 @@
+package power
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"sync"
+)
+
+const (
+	ConfigTypeUnknown = iota
+	ConfigTypeString
+	ConfigTypeMACAddress
+	ConfigTypeChoice
+	ConfigTypePassword
+)
+
+const (
+	ConfigScopeBMC = iota
+	ConfigScopeNode
+)
+
+var (
+	ErrFieldAlreadyDefined  = errors.New("the given field is already defined")
+	ErrTooManyOptionalAttrs = errors.New("too many optional attributes, only one set of optional attributes to a given field may be provied")
+	ErrMustBeTypeChoice     = errors.New("choices can only be provided for a field of type choice")
+	ErrFieldNotFound        = errors.New("the given field is not found in the given config")
+	ErrFieldWrongType       = errors.New("the given field is of a different type than requested")
+	ErrInvalidChoice        = errors.New("invalid choice provided")
+	ErrInvalidType          = errors.New("the given field is defined with an invalid type")
+)
+
+type powerConfigField struct {
+	Key      string
+	Val      string
+	Required bool
+	Default  string
+	Type     int
+	Choices  map[string]string
+	Scope    int
+}
+
+func (p powerConfigField) ValOrDefault() string {
+	if len(p.Val) > 0 {
+		return p.Val
+	}
+	return p.Default
+}
+
+type OptionalFieldAttrs struct {
+	Default string
+	Choices map[string]string
+	Scope   int
+}
+
+type PowerConfig struct {
+	sync.RWMutex
+	cfg map[string]powerConfigField
+}
+
+func (p *PowerConfig) CreateField(name string, fieldType int, required bool, optional ...OptionalFieldAttrs) error {
+	p.Lock()
+	defer p.Unlock()
+
+	if p.cfg == nil {
+		p.cfg = make(map[string]powerConfigField)
+	}
+
+	if _, ok := p.cfg[name]; ok {
+		return fmt.Errorf("%w: %s", ErrFieldAlreadyDefined, name)
+	}
+	if len(optional) > 1 {
+		return ErrTooManyOptionalAttrs
+	}
+
+	field := powerConfigField{
+		Key:      name,
+		Type:     fieldType,
+		Required: required,
+	}
+	if len(optional) == 1 {
+		field.Default = optional[0].Default
+		field.Scope = optional[0].Scope
+		if optional[0].Choices != nil {
+			if field.Type != ConfigTypeChoice {
+				return fmt.Errorf("%w: %s", ErrMustBeTypeChoice, name)
+			}
+			field.Choices = optional[0].Choices
+		}
+	}
+
+	p.cfg[name] = field
+	return nil
+}
+
+func (p *PowerConfig) Get(name string) (string, error) {
+	p.RLock()
+	defer p.RUnlock()
+
+	field, ok := p.cfg[name]
+	if !ok {
+		return "", fmt.Errorf("%w: %s", ErrFieldNotFound, name)
+	}
+	return field.ValOrDefault(), nil
+}
+
+func (p *PowerConfig) Set(name, val string) error {
+	p.Lock()
+	defer p.Unlock()
+
+	field, ok := p.cfg[name]
+	if !ok {
+		return fmt.Errorf("%w: %s", ErrFieldNotFound, name)
+	}
+	switch field.Type {
+	case ConfigTypeString:
+		field.Val = val
+	case ConfigTypeChoice:
+		_, ok := field.Choices[val]
+		if !ok {
+			return fmt.Errorf("%w: %s is an invalid choice for %s", ErrInvalidChoice, val, name)
+		}
+		field.Val = val
+	case ConfigTypeMACAddress:
+		_, err := net.ParseMAC(val)
+		if err != nil {
+			return err
+		}
+		field.Val = val
+	case ConfigTypePassword:
+		field.Val = val
+	default:
+		return fmt.Errorf("%w: %s", ErrInvalidType, name)
+	}
+	p.cfg[name] = field
+	return nil
+}
+
+func (p *PowerConfig) GetMAC(name string) (net.HardwareAddr, error) {
+	field, ok := p.cfg[name]
+	if !ok {
+		return nil, fmt.Errorf("%w: %s", ErrFieldNotFound, name)
+	}
+	if field.Type != ConfigTypeMACAddress {
+		return nil, fmt.Errorf("%w: %s is not of type MAC Address", ErrFieldWrongType, name)
+	}
+	return net.ParseMAC(field.ValOrDefault())
+}
+
+func (p *PowerConfig) GetChoice(name string) (string, error) {
+	field, ok := p.cfg[name]
+	if !ok {
+		return "", fmt.Errorf("%w: %s", ErrFieldNotFound, name)
+	}
+	if field.Type != ConfigTypeChoice {
+		return "", fmt.Errorf("%w: %s is not of type Choice", ErrFieldWrongType, name)
+	}
+	return field.Choices[field.ValOrDefault()], nil
+}
+
+func (p *PowerConfig) GetPassword(name string) (string, error) {
+	field, ok := p.cfg[name]
+	if !ok {
+		return "", fmt.Errorf("%w: %s", ErrFieldNotFound, name)
+	}
+	if field.Type != ConfigTypePassword {
+		return "", fmt.Errorf("%w: %s is not of type Password", ErrFieldWrongType, name)
+	}
+	return field.ValOrDefault(), nil
+}
+
+type PowerDriver interface {
+	Name() string
+	Description() string
+	Settings() PowerConfig
+	IPExactor() (string, string)
+	Queryable() bool
+	Chassis() bool
+	CanProbe() bool
+	CanSetBootOrder() bool
+	DetectMissingPackages() error
+	Schema() map[string]interface{}
+	GetSetting(string) (string, error)
+	PowerOn(context.Context, string, PowerConfig) error
+	PowerOff(context.Context, string, PowerConfig) error
+	PowerCycle(context.Context, string, PowerConfig) error
+	PowerQuery(context.Context, string, PowerConfig) (string, error)
+}
+
+type OrderableBootPowerDriver interface {
+	PowerDriver
+	SetBootOrder(context.Context, string, PowerConfig, []string)
+}
diff --git a/src/rackd_spike/internal/drivers/power/ipmi.go b/src/rackd_spike/internal/drivers/power/ipmi.go
new file mode 100644
index 0000000..165e10e
--- /dev/null
+++ b/src/rackd_spike/internal/drivers/power/ipmi.go
@@ -0,0 +1,248 @@
+package power
+
+import (
+	"context"
+	"net"
+
+	"rackd/internal/drivers"
+	"rackd/internal/drivers/power/ipmi"
+	machinehelpers "rackd/internal/machine_helpers"
+)
+
+const (
+	IPMIDriverLan  = "LAN"
+	IPMIDriverLan2 = "LAN_2_0"
+
+	IPMIBootTypeDefault = "auto"
+	IPMIBootTypeLegacy  = "legacy"
+	IPMIBootTypeEFI     = "efi"
+
+	IPMIPrivilegeLevelUser     = "USER"
+	IPMIPrivilegeLevelOperator = "OPERATOR"
+	IPMIPrivilegeLevelAdmin    = "ADMIN"
+)
+
+var (
+	IPMIWaitTime = [4]int{4, 8, 16, 32}
+
+	IPMIDriverChoices = map[string]string{
+		IPMIDriverLan:  "LAN [IPMI 1.5]",
+		IPMIDriverLan2: "LAN_2_0 [IPMI 2.0]",
+	}
+
+	IPMIBootTypeChoices = map[string]string{
+		IPMIBootTypeDefault: "Automatic",
+		IPMIBootTypeLegacy:  "Legacy boot",
+		IPMIBootTypeEFI:     "EFI boot",
+	}
+
+	IPMIBootTypeMapping = map[string]string{
+		IPMIBootTypeEFI:    "EFI",
+		IPMIBootTypeLegacy: "PC-COMPATIBLE",
+	}
+
+	IPMICipherSuiteIDChoices = map[string]string{
+		"":   "freeipmi-tools default",
+		"17": "17 - HMAC-SHA256::HMAC_SHA256_128::AES-CBC-128",
+		"3":  "3 - HMAC-SHA1::HMAC-SHA1-96::AES-CBC-128",
+		"8":  "8 - HMAC-MD5::HMAC-MD5-128::AES-CBC-128",
+		"12": "12 - HMAC-MD5::MD5-128::AES-CBC-128",
+	}
+
+	IPMIPrivilegeLevelChoices = map[string]string{
+		IPMIPrivilegeLevelUser:     "User",
+		IPMIPrivilegeLevelOperator: "Operator",
+		IPMIPrivilegeLevelAdmin:    "Administrator",
+	}
+)
+
+type IPMIDriver struct {
+	settings *PowerConfig
+}
+
+func NewIPMIDriver() *IPMIDriver {
+	settings := &PowerConfig{}
+	err := settings.CreateField("power_driver", ConfigTypeChoice, true,
+		OptionalFieldAttrs{Default: IPMIDriverLan, Choices: IPMIDriverChoices})
+	if err != nil {
+		panic(err) // All these errors should be the result of something defined at compile-time, so better to error hard
+	}
+	err = settings.CreateField("power_boot_type", ConfigTypeChoice, false,
+		OptionalFieldAttrs{Default: IPMIBootTypeDefault, Choices: IPMIBootTypeChoices})
+	if err != nil {
+		panic(err)
+	}
+	err = settings.CreateField("mac_address", ConfigTypeMACAddress, true)
+	if err != nil {
+		panic(err)
+	}
+	err = settings.CreateField("power_address", ConfigTypeMACAddress, false)
+	if err != nil {
+		panic(err)
+	}
+	err = settings.CreateField("power_user", ConfigTypeString, false)
+	if err != nil {
+		panic(err)
+	}
+	err = settings.CreateField("power_pass", ConfigTypePassword, false)
+	if err != nil {
+		panic(err)
+	}
+	err = settings.CreateField("k_g", ConfigTypePassword, false)
+	if err != nil {
+		panic(err)
+	}
+	err = settings.CreateField("cipher_suite_id", ConfigTypeChoice, false,
+		OptionalFieldAttrs{Default: "3", Choices: IPMICipherSuiteIDChoices})
+	if err != nil {
+		panic(err)
+	}
+	err = settings.CreateField("privilege_level", ConfigTypeChoice, false,
+		OptionalFieldAttrs{Default: IPMIPrivilegeLevelOperator, Choices: IPMIPrivilegeLevelChoices})
+	if err != nil {
+		panic(err)
+	}
+	return &IPMIDriver{
+		settings: settings,
+	}
+}
+
+func (i *IPMIDriver) Name() string {
+	return "ipmi"
+}
+
+func (i *IPMIDriver) Description() string {
+	return "IPMI"
+}
+
+func (i *IPMIDriver) Settings() *PowerConfig {
+	return i.settings
+}
+
+func (i *IPMIDriver) IPExtractor() drivers.IPExtractor {
+	return drivers.NewIPExtractor("power_address", drivers.IPExtractorIdentity)
+}
+
+func (i *IPMIDriver) Queryable() bool {
+	return false
+}
+
+func (i *IPMIDriver) Chassis() bool {
+	return false
+}
+
+func (i *IPMIDriver) CanProbe() bool {
+	return false
+}
+
+func (i *IPMIDriver) CanSetBootOrder() bool {
+	return false
+}
+
+func (i *IPMIDriver) DetectMissingPackages() error {
+	return nil
+}
+
+func (i *IPMIDriver) Schema() map[string]interface{} {
+	return nil
+}
+
+func (i *IPMIDriver) GetSetting(field string) (string, error) {
+	return "", nil
+}
+
+func (i *IPMIDriver) connFromCfg(ctx context.Context, cfg *PowerConfig) (*ipmi.LanConn, error) {
+	remoteIPStr, err := cfg.Get("power_address")
+	if err != nil {
+		return nil, err
+	}
+
+	var remoteIP net.IP
+	if len(remoteIPStr) == 0 {
+		mac, err := cfg.GetMAC("mac_address")
+		if err != nil {
+			return nil, err
+		}
+		remoteIP, err = machinehelpers.FindIPByArp(ctx, mac)
+		if err != nil {
+			return nil, err
+		}
+	}
+	user, err := cfg.Get("power_user")
+	if err != nil {
+		return nil, err
+	}
+	password, err := cfg.Get("power_pass")
+	if err != nil {
+		return nil, err
+	}
+	privLvl, err := cfg.GetChoice("privilege_level")
+	if err != nil {
+		return nil, err
+	}
+	info := ipmi.ConnInfo{
+		Port:     623,
+		IP:       remoteIP.String(),
+		BindAddr: "0.0.0.0",
+		Username: user,
+		Password: password,
+		PrivLvl:  privLvl,
+	}
+	return ipmi.NewLanConn(info), nil
+}
+
+func (i *IPMIDriver) applyConfig(conn *ipmi.LanConn, cfg *PowerConfig) error {
+	err := conn.SetBootDevice(ipmi.IPMIBootDevicePxe)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (i *IPMIDriver) PowerOn(ctx context.Context, systemID string, cfg *PowerConfig) error {
+	conn, err := i.connFromCfg(ctx, cfg)
+	if err != nil {
+		return err
+	}
+	err = conn.Open()
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+	err = conn.StartSession()
+	if err != nil {
+		return err
+	}
+	defer conn.EndSession()
+	err = i.applyConfig(conn, cfg)
+	if err != nil {
+		return err
+	}
+	return conn.PowerCtrl(ipmi.IPMIPowerStateOn)
+}
+
+func (i *IPMIDriver) PowerOff(ctx context.Context, systemID string, cfg *PowerConfig) error {
+	conn, err := i.connFromCfg(ctx, cfg)
+	if err != nil {
+		return err
+	}
+	err = conn.Open()
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+	err = conn.StartSession()
+	if err != nil {
+		return err
+	}
+	defer conn.EndSession()
+	err = i.applyConfig(conn, cfg)
+	if err != nil {
+		return err
+	}
+	return conn.PowerCtrl(ipmi.IPMIPowerStateOff)
+}
+
+func (i *IPMIDriver) PowerQuery(ctx context.Context, systemID string, cfg *PowerConfig) error {
+	return nil
+}
diff --git a/src/rackd_spike/internal/drivers/power/ipmi/conn.go b/src/rackd_spike/internal/drivers/power/ipmi/conn.go
new file mode 100644
index 0000000..62eaf7e
--- /dev/null
+++ b/src/rackd_spike/internal/drivers/power/ipmi/conn.go
@@ -0,0 +1,656 @@
+package ipmi
+
+import (
+	"bytes"
+	"crypto/md5"
+	"crypto/rand"
+	"encoding"
+	"encoding/binary"
+	"io"
+	"net"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+)
+
+const (
+	recvBufferSize = 1024
+)
+
+const (
+	IPMICMDGetDeviceID              uint8 = 0x01
+	IPMICMDChassisStatus            uint8 = 0x01
+	IPMICMDChassisControl           uint8 = 0x02
+	IPMICMDSetSystemBootOptions     uint8 = 0x08
+	IPMICMDGetSystemBootOptions     uint8 = 0x09
+	IPMICMDAuthCapabilities         uint8 = 0x38
+	IPMICMDGetSessionChallenge      uint8 = 0x39
+	IPMICMDActivateSession          uint8 = 0x3a
+	IPMICMDSetSessionPrivilegeLevel uint8 = 0x3b
+	IPMICMDCloseSession             uint8 = 0x3c
+	IPMICMDSetUsername              uint8 = 0x45
+	IPMICMDGetUsername              uint8 = 0x46
+
+	IPMIBootDeviceNone          uint8 = 0x00
+	IPMIBootDevicePxe           uint8 = 0x04
+	IPMIBootDeviceDisk          uint8 = 0x08
+	IPMIBootDeviceSafe          uint8 = 0x0c
+	IPMIBootDeviceDiag          uint8 = 0x10
+	IPMIBootDeviceCDROM         uint8 = 0x14
+	IPMIBootDeviceBios          uint8 = 0x18
+	IPMIBootDeviceRemoteFloppy  uint8 = 0x1c
+	IPMIBootDeviceRemoteCDROM   uint8 = 0x20
+	IPMIBootDeviceRemotePrimary uint8 = 0x24
+	IPMIBootDeviceRemoteDisk    uint8 = 0x2c
+	IPMIBootDeviceFloppy        uint8 = 0x3c
+
+	IPMIAuthTypeNone     uint8 = 0x0
+	IPMIAuthTypeMD2      uint8 = 0x1
+	IPMIAuthTypeMD5      uint8 = 0x2
+	IPMIAuthTypeKey      uint8 = 0x4
+	IPMIAuthTypePassword uint8 = 0x4
+	IPMIAuthTypeOEM      uint8 = 0x5
+	IPMIAuthTypeRMCPPlus uint8 = 0x6
+)
+
+const (
+	IPMIInProgressSetComplete uint8 = iota
+	IPMIInProgressInProgress
+	IPMIInProgressCommit
+)
+
+const (
+	IPMIPowerStateOff uint8 = iota
+	IPMIPowerStateOn
+	IPMIPowerStateCycle
+	IPMIPowerStateHardReset
+	IPMIPowerStatePulseDiag
+	IPMIPowerStateAcpiSoft
+)
+
+const (
+	IPMIBootParamInProgress uint8 = iota
+	IPMIBootParamSvcPartSelect
+	IPMIBootParamSvcPartScan
+	IPMIBootParamFlagValid
+	IPMIBootParamInfoAck
+	IPMIBootParamBootFlags
+	IPMIBootParamInitInfo
+	IPMIBootParamInitMbox
+)
+
+const (
+	IPMIPrivLevelNone = iota
+	IPMIPrivLevelCallback
+	IPMIPrivLevelUser
+	IPMIPrivLevelOperator
+	IPMIPrivLevelAdmin
+	IPMIPrivLevelOEM
+)
+
+type ConnInfo struct {
+	Port     int
+	Path     string
+	IP       string
+	BindAddr string
+	Username string
+	Password string
+	PrivLvl  string
+}
+
+type Request struct {
+	NetworkFn uint8
+	Cmd       uint8
+	Data      interface{}
+}
+
+type Response interface {
+	encoding.BinaryUnmarshaler
+	Data() interface{}
+}
+
+type LanConn struct {
+	Session    session
+	IPMIHeader ipmiHeader
+	Info       ConnInfo
+	rqSeq      uint8
+	transport  net.Conn
+	connected  bool
+	authCode   [16]byte
+	username   [16]byte
+	priv       uint8
+	lun        uint8
+	timeout    time.Duration
+}
+
+func NewLanConn(info ConnInfo) *LanConn {
+	conn := &LanConn{
+		Info: info,
+	}
+	switch strings.ToLower(info.PrivLvl) {
+	case "user":
+		conn.priv = IPMIPrivLevelUser
+	case "operator":
+		conn.priv = IPMIPrivLevelOperator
+	case "administrator":
+		conn.priv = IPMIPrivLevelAdmin
+	}
+	copy(conn.username[:], info.Username[:])
+	copy(conn.authCode[:], info.Password[:])
+	return conn
+}
+
+func (l *LanConn) Open() error {
+	lAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(l.Info.BindAddr, "0"))
+	if err != nil {
+		return err
+	}
+	rAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(l.Info.IP, strconv.Itoa(l.Info.Port)))
+	if err != nil {
+		return err
+	}
+	conn, err := net.DialUDP("udp", lAddr, rAddr)
+	if err != nil {
+		return err
+	}
+	l.transport = conn
+	l.connected = true
+	return nil
+}
+
+func (l *LanConn) Close() error {
+	if l.connected {
+		l.Session = session{}
+		return l.transport.Close()
+	}
+	return nil
+}
+
+func (l *LanConn) nextSeq() uint32 {
+	if l.Session.Seq != 0 {
+		atomic.AddUint32(&l.Session.Seq, 1)
+	}
+	return atomic.LoadUint32(&l.Session.Seq) << 2
+}
+
+func (l *LanConn) nextRqSeq() uint8 {
+	l.IPMIHeader.RqSeq++
+	return l.IPMIHeader.RqSeq
+}
+
+func (l *LanConn) sigMD5(data []byte) []byte {
+	hash := md5.New()
+	binary.Write(hash, binary.BigEndian, l.authCode)
+	binary.Write(hash, binary.BigEndian, l.Session.ID)
+	binary.Write(hash, binary.BigEndian, data)
+	binary.Write(hash, binary.BigEndian, l.Session.Seq)
+	binary.Write(hash, binary.BigEndian, l.authCode)
+	return hash.Sum(nil)
+}
+
+func (l *LanConn) Send(req *Request, resp Response) error {
+	pkt := &Packet{
+		RMCPHeader: rmcpHeader{
+			Version:  rmcpV1,
+			Sequence: 0xff,
+			Class:    rmcpClassIPMI,
+		},
+		Session: session{
+			AuthType: l.Session.AuthType,
+			Seq:      l.nextSeq(),
+			ID:       l.Session.ID,
+		},
+		IPMIHeader: ipmiHeader{
+			RsAddr:     0x20,
+			NetFnRsLUN: req.NetworkFn<<2 | l.IPMIHeader.NetFnRsLUN&3,
+			Cmd:        req.Cmd,
+			RqAddr:     0x81,
+			RqSeq:      l.nextRqSeq(),
+		},
+	}
+
+	if l.Session.AuthType != 0 {
+		copy(pkt.AuthCode[:], l.authCode[:])
+	}
+
+	err := pkt.SetData(req.Data)
+	if err != nil {
+		return err
+	}
+
+	msg, err := MarshalPacket(pkt)
+	if err != nil {
+		return err
+	}
+
+	if l.Session.AuthType == IPMIAuthTypeMD5 {
+		hlen := binary.Size(rmcpHeader{}) + binary.Size(session{})
+		offset := hlen + len(pkt.AuthCode) + 1
+		sig := l.sigMD5(msg[offset:])
+		copy(msg[hlen:], sig)
+	}
+
+	_, err = l.transport.Write(msg)
+	if err != nil {
+		return err
+	}
+
+	buf := make([]byte, recvBufferSize)
+	if l.timeout > 0 {
+		err = l.transport.SetReadDeadline(time.Now().Add(l.timeout))
+		if err != nil {
+			return err
+		}
+	}
+	n, err := l.transport.Read(buf)
+	if err != nil && err != io.EOF {
+		return err
+	}
+	rPkt, err := UnmarshalPacket(buf[:n])
+	if err != nil {
+		return err
+	}
+	if resp != nil {
+		return resp.UnmarshalBinary(rPkt.Data)
+	}
+	return nil
+}
+
+func (l *LanConn) genSeq() ([4]byte, error) {
+	var seq [4]byte
+	_, err := rand.Read(seq[:])
+	if err != nil {
+		return seq, err
+	}
+	return seq, nil
+}
+
+func (l *LanConn) Ping() (err error) {
+	pkt := &ASFPacket{
+		RMCPHeader: rmcpHeader{
+			Version:  rmcpV1,
+			Class:    rmcpClassASF,
+			Sequence: 0xff,
+		},
+		ASFHeader: asfHeader{
+			IANANum: ianaASF,
+			Type:    asfTypePing,
+		},
+	}
+
+	payload := MarshalASFPacket(pkt)
+	_, err = l.transport.Write(payload)
+	if err != nil {
+		return err
+	}
+	buf := make([]byte, recvBufferSize)
+	if l.timeout > 0 {
+		err = l.transport.SetReadDeadline(time.Now().Add(l.timeout))
+		if err != nil {
+			return err
+		}
+	}
+
+	n, err := l.transport.Read(buf)
+	if err != nil {
+		return err
+	}
+	pkt, err = UnmarshalASFPacket(buf[n:])
+	if err != nil {
+		return err
+	}
+	return pkt.ValidatePong()
+}
+
+type AuthCapReq struct {
+	Channel   uint8
+	PrivLevel uint8
+}
+
+type AuthCapResp struct {
+	Channel         uint8
+	AuthTypeSupport uint8
+	Flags           uint8
+	V1              uint8
+	V2              uint8
+	OEMID           [3]byte
+	OEMAux          uint8
+}
+
+func (a *AuthCapResp) UnmarshalBinary(b []byte) error {
+	buf := bytes.NewReader(b)
+	err := binary.Read(buf, binary.BigEndian, a)
+	if err != nil && err != io.EOF {
+		return err
+	}
+	return nil
+}
+
+func (a *AuthCapResp) Data() interface{} {
+	return a
+}
+
+func (l *LanConn) GetAuthCaps() (*AuthCapResp, error) {
+	req := &Request{
+		NetworkFn: NetworkFnApp,
+		Cmd:       IPMICMDAuthCapabilities,
+		Data: AuthCapReq{
+			Channel:   0x0e,
+			PrivLevel: l.priv,
+		},
+	}
+	var resp AuthCapResp
+
+	err := l.Send(req, &resp)
+	if err != nil {
+		return nil, err
+	}
+
+	return &resp, nil
+}
+
+type SessionChallengeRequest struct {
+	AuthType uint8
+	Username [16]byte
+}
+
+type SessionChallengeResp struct {
+	Code      uint8
+	SessionID uint32
+	Challenge [16]byte
+}
+
+func (s *SessionChallengeResp) UnmarshalBinary(b []byte) error {
+	buf := bytes.NewReader(b)
+	return binary.Read(buf, binary.BigEndian, s)
+}
+
+func (s *SessionChallengeResp) Data() interface{} {
+	return s
+}
+
+func (l *LanConn) GetSessionChallenge(authType uint8) (*SessionChallengeResp, error) {
+	req := &Request{
+		NetworkFn: NetworkFnApp,
+		Cmd:       IPMICMDGetSessionChallenge,
+		Data: SessionChallengeRequest{
+			AuthType: authType,
+			Username: l.username,
+		},
+	}
+	var resp SessionChallengeResp
+
+	err := l.Send(req, &resp)
+	if err != nil {
+		return nil, err
+	}
+	l.Session.AuthType = authType
+	return &resp, nil
+}
+
+type ActivateSessionReq struct {
+	AuthType  uint8
+	PrivLevel uint8
+	AuthCode  [16]byte
+	Seq       [4]byte
+}
+
+type ActivateSessionResp struct {
+	Code      uint8
+	AuthType  uint8
+	SessionID uint32
+	Seq       uint32
+	MaxPriv   uint8
+}
+
+func (a *ActivateSessionResp) UnmarshalBinary(b []byte) error {
+	buf := bytes.NewReader(b)
+	return binary.Read(buf, binary.BigEndian, a)
+}
+
+func (a *ActivateSessionResp) Data() interface{} {
+	return a
+}
+
+func (l *LanConn) ActivateSession(challenge *SessionChallengeResp) error {
+	outboundSeq, err := l.genSeq()
+	if err != nil {
+		return err
+	}
+	req := &Request{
+		NetworkFn: NetworkFnApp,
+		Cmd:       IPMICMDActivateSession,
+		Data: ActivateSessionReq{
+			AuthType:  l.Session.AuthType,
+			PrivLevel: l.priv,
+			AuthCode:  challenge.Challenge,
+			Seq:       outboundSeq,
+		},
+	}
+	var resp ActivateSessionResp
+	err = l.Send(req, &resp)
+	if err != nil {
+		return err
+	}
+
+	l.connected = true
+	l.Session.ID = resp.SessionID
+	l.Session.AuthType = resp.AuthType
+	l.Session.Seq = resp.Seq
+	return nil
+}
+
+type SetPrivilegeReq struct {
+	Priv uint8
+}
+
+type SetPrivilegeResponse struct {
+	Code uint8
+	Priv uint8
+}
+
+func (s *SetPrivilegeResponse) UnmarshalBinary(b []byte) error {
+	buf := bytes.NewReader(b)
+	return binary.Read(buf, binary.BigEndian, s)
+}
+
+func (s *SetPrivilegeResponse) Data() interface{} {
+	return s
+}
+
+func (l *LanConn) SetPrivilege() error {
+	req := &Request{
+		NetworkFn: NetworkFnApp,
+		Cmd:       IPMICMDSetSessionPrivilegeLevel,
+		Data: SetPrivilegeReq{
+			Priv: l.priv,
+		},
+	}
+	var resp SetPrivilegeResponse
+	err := l.Send(req, &resp)
+	if err != nil {
+		return err
+	}
+	l.priv = resp.Priv
+	return nil
+}
+
+func (l *LanConn) StartSession() error {
+	err := l.Ping()
+	if err != nil {
+		return err
+	}
+	authCaps, err := l.GetAuthCaps()
+	if err != nil {
+		return err
+	}
+
+	authType := IPMIAuthTypeNone
+	for _, authT := range []uint8{IPMIAuthTypeMD5, IPMIAuthTypePassword, IPMIAuthTypeMD2} {
+		if authCaps.AuthTypeSupport&authT == 0 {
+			authType = authT
+			break
+		}
+	}
+
+	challenge, err := l.GetSessionChallenge(authType)
+	if err != nil {
+		return err
+	}
+
+	err = l.ActivateSession(challenge)
+	if err != nil {
+		return err
+	}
+	return l.SetPrivilege()
+}
+
+type CloseSessionReq struct {
+	SessionID uint32
+}
+
+func (l *LanConn) EndSession() error {
+	req := &Request{
+		NetworkFn: NetworkFnApp,
+		Cmd:       IPMICMDCloseSession,
+		Data: CloseSessionReq{
+			SessionID: l.Session.ID,
+		},
+	}
+	return l.Send(req, nil)
+}
+
+type DeviceIDResp struct {
+	Code                    uint8
+	DeviceID                uint8
+	DeviceRevision          uint8
+	FirmwareRevision1       uint8
+	FirmwareRevision2       uint8
+	IPMIVersion             uint8
+	AdditionalDeviceSupport uint8
+	ManufacturerID          uint16
+	ProductID               uint16
+}
+
+func (d *DeviceIDResp) UnmarshalBinary(b []byte) error {
+	buf := bytes.NewReader(b)
+	return binary.Read(buf, binary.BigEndian, d)
+}
+
+func (d *DeviceIDResp) Data() interface{} {
+	return d
+}
+
+func (l *LanConn) DeviceID() (*DeviceIDResp, error) {
+	req := &Request{
+		NetworkFn: NetworkFnApp,
+		Cmd:       IPMICMDGetDeviceID,
+	}
+	var resp DeviceIDResp
+	err := l.Send(req, &resp)
+	if err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+type SetBootOptionsReq struct {
+	Param uint8
+	Data  []uint8
+}
+
+func (l *LanConn) SetBootParam(param uint8, vals ...uint8) error {
+	req := &Request{
+		NetworkFn: NetworkFnChassis,
+		Cmd:       IPMICMDSetSystemBootOptions,
+		Data: SetBootOptionsReq{
+			Param: param,
+			Data:  vals,
+		},
+	}
+	return l.Send(req, nil)
+}
+
+func (l *LanConn) SetBootDevice(bootDev uint8) error {
+	err := l.SetBootParam(IPMIBootParamInProgress, IPMIInProgressInProgress)
+	if err != nil {
+		return err
+	}
+	defer l.SetBootParam(IPMIBootParamInProgress, IPMIInProgressSetComplete)
+
+	err = l.SetBootParam(IPMIBootParamInfoAck, 0x01, 0x01)
+	if err != nil {
+		return err
+	}
+
+	err = l.SetBootParam(IPMIBootParamBootFlags, 0x80, bootDev, 0x00, 0x00, 0x00)
+	if err != nil {
+		return err
+	}
+	err = l.SetBootParam(IPMIBootParamInProgress, IPMIInProgressCommit)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (l *LanConn) PowerCtrl(state uint8) error {
+	req := &Request{
+		NetworkFn: NetworkFnChassis,
+		Cmd:       IPMICMDChassisControl,
+		Data:      state,
+	}
+	return l.Send(req, nil)
+}
+
+type GetUsernameReq struct {
+	UserID uint8
+}
+
+type GetUsernameResp struct {
+	Code     uint8
+	Username string
+}
+
+func (g *GetUsernameResp) UnmarshalBinary(b []byte) error {
+	buf := bytes.NewReader(b)
+	return binary.Read(buf, binary.BigEndian, g)
+}
+
+func (g *GetUsernameResp) Data() interface{} {
+	return g
+}
+
+func (l *LanConn) GetUserName(id uint8) (string, error) {
+	req := &Request{
+		NetworkFn: NetworkFnApp,
+		Cmd:       IPMICMDGetUsername,
+		Data: GetUsernameReq{
+			UserID: id,
+		},
+	}
+	var resp GetUsernameResp
+	err := l.Send(req, &resp)
+	if err != nil {
+		return "", err
+	}
+	return resp.Username, nil
+}
+
+type SetUsernameReq struct {
+	UserID   uint8
+	Username string
+}
+
+func (l *LanConn) SetUsername(id uint8, username string) error {
+	req := &Request{
+		NetworkFn: NetworkFnApp,
+		Cmd:       IPMICMDSetUsername,
+		Data: SetUsernameReq{
+			UserID:   id,
+			Username: username,
+		},
+	}
+	return l.Send(req, nil)
+}
diff --git a/src/rackd_spike/internal/drivers/power/ipmi/packet.go b/src/rackd_spike/internal/drivers/power/ipmi/packet.go
new file mode 100644
index 0000000..a6a1fa5
--- /dev/null
+++ b/src/rackd_spike/internal/drivers/power/ipmi/packet.go
@@ -0,0 +1,287 @@
+package ipmi
+
+import (
+	"bytes"
+	"encoding"
+	"encoding/binary"
+	"errors"
+	"fmt"
+)
+
+const (
+	rmcpClassASF      uint8 = 0x06
+	rmcpClassIPMI     uint8 = 0x07
+	rmcpClassNoAckSeq uint8 = 0xff
+
+	rmcpV1 uint8 = 0x06
+
+	ianaASF uint32 = 0x000011be
+
+	asfTypePing uint8 = 0x80
+	asfTypePong uint8 = 0x40
+
+	NetworkFnChassis uint8 = 0x00
+	NetworkFnApp     uint8 = 0x06
+)
+
+var (
+	minPktSize = binary.Size(rmcpHeader{}) + binary.Size(session{}) + binary.Size(ipmiHeader{})
+
+	ErrInvalidPacket = errors.New("the received packet is invalid")
+)
+
+func computeChecksum(data ...uint8) uint8 {
+	var checksum uint8
+	for _, d := range data {
+		checksum += d
+	}
+	return -checksum
+}
+
+type rmcpHeader struct {
+	Version  uint8
+	Reserved uint8
+	Sequence uint8
+	Class    uint8
+}
+
+func (r *rmcpHeader) IsAck() bool {
+	return r.Class&0x80 != 0
+}
+
+type session struct {
+	AuthType uint8
+	Seq      uint32
+	ID       uint32
+}
+
+type ipmiHeader struct {
+	Len        uint8
+	RsAddr     uint8
+	NetFnRsLUN uint8
+	Checksum   uint8
+	RqAddr     uint8
+	RqSeq      uint8
+	Cmd        uint8
+}
+
+type Packet struct {
+	RMCPHeader rmcpHeader
+	Session    session
+	AuthCode   [16]byte
+	IPMIHeader ipmiHeader
+	Data       []byte
+}
+
+func (p *Packet) SetData(data interface{}) error {
+	if data == nil {
+		return nil
+	}
+	if encoder, ok := data.(encoding.BinaryMarshaler); ok {
+		buf, err := encoder.MarshalBinary()
+		if err != nil {
+			return err
+		}
+		p.Data = buf
+		return nil
+	}
+	byteBuf := &bytes.Buffer{}
+	err := binary.Write(byteBuf, binary.BigEndian, data)
+	if err != nil {
+		return err
+	}
+	p.Data = byteBuf.Bytes()
+	return nil
+}
+
+func MarshalPacket(p *Packet) ([]byte, error) {
+	buf := &bytes.Buffer{}
+
+	err := binary.Write(buf, binary.BigEndian, &p.RMCPHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	err = binary.Write(buf, binary.BigEndian, &p.Session)
+	if err != nil {
+		return nil, err
+	}
+
+	if p.Session.AuthType != IPMIAuthTypeNone {
+		err = binary.Write(buf, binary.BigEndian, p.AuthCode)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	p.IPMIHeader.Len = uint8(binary.Size(p.IPMIHeader) + len(p.Data))
+	p.IPMIHeader.Checksum = computeChecksum(p.IPMIHeader.RsAddr, p.IPMIHeader.NetFnRsLUN)
+	err = binary.Write(buf, binary.BigEndian, &p.IPMIHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = buf.Write(p.Data)
+	if err != nil {
+		return nil, err
+	}
+
+	payloadChecksum := computeChecksum(p.IPMIHeader.RqAddr, p.IPMIHeader.RqSeq, p.IPMIHeader.Cmd) + computeChecksum(p.Data...)
+
+	err = binary.Write(buf, binary.BigEndian, payloadChecksum)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func UnmarshalPacket(buf []byte) (*Packet, error) {
+	if len(buf) < minPktSize {
+		return nil, fmt.Errorf("%w: too short", ErrInvalidPacket)
+	}
+
+	pkt := &Packet{}
+	reader := bytes.NewReader(buf)
+
+	err := binary.Read(reader, binary.BigEndian, &pkt.RMCPHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	err = binary.Read(reader, binary.BigEndian, &pkt.Session)
+	if err != nil {
+		return nil, err
+	}
+	if pkt.Session.AuthType != 0 {
+		err = binary.Read(reader, binary.BigEndian, pkt.AuthCode)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = binary.Read(reader, binary.BigEndian, &pkt.IPMIHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	if computeChecksum(pkt.IPMIHeader.RsAddr, pkt.IPMIHeader.NetFnRsLUN) != pkt.IPMIHeader.Checksum {
+		return nil, fmt.Errorf("%w: checksum does not match", ErrInvalidPacket)
+	}
+	if pkt.IPMIHeader.Len <= 0 {
+		return nil, fmt.Errorf("%w: malformed message len", ErrInvalidPacket)
+	}
+
+	dataLen := int(pkt.IPMIHeader.Len) - binary.Size(ipmiHeader{})
+	data := make([]byte, dataLen+1)
+	_, err = reader.Read(data)
+	if err != nil {
+		return nil, err
+	}
+
+	dataChecksum := data[len(data)-1]
+	localChecksum := computeChecksum(
+		pkt.IPMIHeader.RqAddr,
+		pkt.IPMIHeader.RqSeq,
+		pkt.IPMIHeader.Cmd,
+	) + computeChecksum(data[:len(data)-1]...)
+	if dataChecksum != localChecksum {
+		return nil, fmt.Errorf("%w: checksum does not match", ErrInvalidPacket)
+	}
+
+	pkt.Data = data[:len(data)-1]
+	return pkt, nil
+}
+
+func Marshal(data interface{}) ([]byte, error) {
+	pkt := &Packet{}
+	pkt.SetData(data)
+	return MarshalPacket(pkt)
+}
+
+func Unmarshal(buf []byte, data interface{}) error {
+	pkt, err := UnmarshalPacket(buf)
+	if err != nil {
+		return err
+	}
+	if decoder, ok := data.(encoding.BinaryUnmarshaler); ok {
+		return decoder.UnmarshalBinary(pkt.Data)
+	}
+	reader := bytes.NewReader(buf)
+	err = binary.Read(reader, binary.BigEndian, pkt.Data)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type asfHeader struct {
+	IANANum  uint32
+	Type     uint8
+	Tag      uint8
+	Reserved uint8
+	DataLen  uint8
+}
+
+type ASFPong struct {
+	IANANum               uint32
+	OEM                   uint32
+	Entities              uint8
+	SupportedInteractions uint8
+	Reserved              [6]uint8
+}
+
+type ASFPacket struct {
+	RMCPHeader rmcpHeader
+	ASFHeader  asfHeader
+	Data       []byte
+}
+
+func (a *ASFPacket) SetData(data interface{}) (err error) {
+	if encoder, ok := data.(encoding.BinaryMarshaler); ok {
+		a.Data, err = encoder.MarshalBinary()
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+	buf := &bytes.Buffer{}
+	err = binary.Write(buf, binary.BigEndian, data)
+	if err != nil {
+		return err
+	}
+	a.Data = buf.Bytes()
+	return nil
+}
+
+func (a *ASFPacket) ValidatePong() error {
+	return nil
+}
+
+func MarshalASFPacket(pkt *ASFPacket) []byte {
+	buf := &bytes.Buffer{}
+	binary.Write(buf, binary.BigEndian, pkt.RMCPHeader)
+	binary.Write(buf, binary.BigEndian, pkt.ASFHeader)
+	buf.Write(pkt.Data)
+	return buf.Bytes()
+}
+
+func UnmarshalASFPacket(buf []byte) (*ASFPacket, error) {
+	hlen := binary.Size(rmcpHeader{}) + binary.Size(asfHeader{})
+	if len(buf) < hlen {
+		return nil, fmt.Errorf("%w: too short", ErrInvalidPacket)
+	}
+	var pkt ASFPacket
+	reader := bytes.NewReader(buf)
+	fullLen := reader.Len()
+	err := binary.Read(reader, binary.BigEndian, &pkt.RMCPHeader)
+	if err != nil {
+		return nil, err
+	}
+	err = binary.Read(reader, binary.BigEndian, &pkt.ASFHeader)
+	remainder := fullLen - reader.Len()
+	if remainder > 0 {
+		copy(pkt.Data[:], buf[remainder:])
+	}
+	return &pkt, nil
+}
diff --git a/src/rackd_spike/internal/machine_helpers/arp.go b/src/rackd_spike/internal/machine_helpers/arp.go
new file mode 100644
index 0000000..3c9e6c5
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/arp.go
@@ -0,0 +1,39 @@
+package machinehelpers
+
+import (
+	"context"
+	"errors"
+	"net"
+	"os/exec"
+	"strings"
+)
+
+var (
+	ErrIPNotFound = errors.New("ip not found for given mac address")
+)
+
+func FindIPByArp(ctx context.Context, mac net.HardwareAddr) (net.IP, error) {
+	cmd := exec.CommandContext(ctx, "arp", "-n")
+
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, line := range strings.Split(string(out), "\n") {
+		columns := strings.Split(line, "  ")
+		var strippedColumns []string
+		for _, column := range columns {
+			column = strings.TrimSpace(column)
+			if column == "" {
+				continue
+			}
+			strippedColumns = append(strippedColumns, column)
+		}
+		columns = strippedColumns
+		if len(columns) == 5 && strings.ToLower(columns[2]) == strings.ToLower(mac.String()) {
+			return net.ParseIP(columns[0]), nil
+		}
+	}
+	return nil, ErrIPNotFound
+}