diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index f869ba3..949686e 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -19,7 +19,13 @@ jobs: go-version: 1.17 - name: Build - run: go build -v ./... + run: make + + # Run vet & lint on the code + - name: Run vet & lint + run: | + go vet . + golint . - name: Test run: go test -v ./... diff --git a/.gitignore b/.gitignore index 66fd13c..0effd7f 100644 --- a/.gitignore +++ b/.gitignore @@ -13,3 +13,6 @@ # Dependency directories (remove the comment below to include it) # vendor/ + +*.bak +local_test.go diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..367f479 --- /dev/null +++ b/Makefile @@ -0,0 +1,10 @@ +build: install-tools generate-sources + +install-tools: + go install $$(go list -f '{{join .Imports " "}}' tools.go) + +generate-sources: + go generate ./... + +compile-sources: + go build ./... diff --git a/README.md b/README.md index 28870ac..76b2180 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,18 @@ # go-amt Client library to interact with Intel AMT api (via wsman) + + +## Usage + +```golang +connection := Connection{ + Host: "192.168.32.6", + User: "admin", + Pass: "yourreallyawesomepassword", +} +client, err := NewClient(&connection) +assert.NoError(t, err) + +err = client.PowerOn() +assert.NoError(t, err) +``` \ No newline at end of file diff --git a/amt.go b/amt.go new file mode 100644 index 0000000..e9867b0 --- /dev/null +++ b/amt.go @@ -0,0 +1,5 @@ +package amt + +const ( + resourceAMTBootSettingData = "http://intel.com/wbem/wscim/1/amt-schema/1/AMT_BootSettingData" +) diff --git a/boot.go b/boot.go new file mode 100644 index 0000000..db44048 --- /dev/null +++ b/boot.go @@ -0,0 +1,149 @@ +//go:generate stringer -type=bootConfigRole -trimprefix=bootConfigRole -linecomment + +package amt + +import ( + "fmt" + "strconv" + + "github.com/VictorLowther/simplexml/dom" + "github.com/VictorLowther/simplexml/search" +) + +type bootConfigRole int + +const ( + bootConfigRoleIsNext bootConfigRole = 0 + bootConfigRoleIsNextSingleUse bootConfigRole = 1 + bootConfigRoleIsDefault bootConfigRole = 2 + bootConfigRoleDMTFReserved bootConfigRole = 3 // 3..32767 + bootConfigRoleVendorSpecified bootConfigRole = 32768 // 32768..65535 +) + +func setBootConfigRole(client *Client, role bootConfigRole) error { + bootConfigRef, err := getBootConfigSettingRef(client, "Intel(r) AMT: Boot Configuration 0") + if err != nil { + return err + } + + message := client.wsManClient.Invoke(resourceCIMBootService, "SetBootConfigRole") + bootConfigSetting := message.MakeParameter("BootConfigSetting") + bootConfigSetting.AddChildren(bootConfigRef.Children()...) + message.AddParameter(bootConfigSetting) + message.Parameters("Role", strconv.Itoa(int(role))) + + _, err = sendMessageForReturnValueInt(message) + if err != nil { + return err + } + return nil +} + +func changeBootOrder(client *Client, items []string) error { + message := client.wsManClient.Invoke(resourceCIMBootConfigSetting, "ChangeBootOrder") + + if len(items) > 0 { + // TODO: multiple? + pxeEndpointRef, err := getBootSourceRef(client, "Intel(r) AMT: Force PXE Boot") + if err != nil { + return err + } + sourceParam := message.MakeParameter("Source") + sourceParam.AddChildren(pxeEndpointRef.Children()...) + message.AddParameter(sourceParam) + } + + _, err := sendMessageForReturnValueInt(message) + if err != nil { + return err + } + return nil +} + +func getBootSettingData(client *Client) ([]*dom.Element, error) { + msg := client.wsManClient.Get(resourceAMTBootSettingData) + response, err := msg.Send() + if err != nil { + return nil, err + } + data := search.FirstTag("AMT_BootSettingData", resourceAMTBootSettingData, response.Body()) + if data == nil { + return nil, fmt.Errorf("response was missing the AMT_BootSettingData") + } + return data.Children(), nil +} + +func setBootSettingData(client *Client) error { + bootSettings, err := getBootSettingData(client) + if err != nil { + return err + } + + settingsToKeep := []*dom.Element{} + for _, setting := range bootSettings { + switch setting.Name.Local { + // omit these ones ... they are read-only parameters (per meshcommand implementation) + case "WinREBootEnabled", + "UEFILocalPBABootEnabled", + "UEFIHTTPSBootEnabled", + "SecureBootControlEnabled", + "BootguardStatus", + "OptionsCleared", + "BIOSLastStatus", + "UefiBootParametersArray": + continue + // gonna make sure these are set to "false" + case "BIOSPause", "BIOSSetup": + setting.Content = []byte("false") + settingsToKeep = append(settingsToKeep, setting) + // gonna make sure these are set to "0" + case "BootMediaIndex": + setting.Content = []byte("0") + settingsToKeep = append(settingsToKeep, setting) + default: + settingsToKeep = append(settingsToKeep, setting) + } + } + + msg := client.wsManClient.Put(resourceAMTBootSettingData) + data := dom.Elem("AMT_BootSettingData", resourceAMTBootSettingData) + data.AddChildren(settingsToKeep...) + msg.SetBody(data) + _, err = msg.Send() + + return err +} + +func setPXE(client *Client) error { + // clear existing boot order per meshcommander's implementation... + // "Set the boot order to null, this is needed for some AMT versions that don't clear this automatically." + // err := changeBootOrder(client, []string{}) + // if err != nil { + // return err + // } + + err := setBootSettingData(client) + if err != nil { + return err + } + + err = setBootConfigRole(client, bootConfigRoleIsNextSingleUse) + if err != nil { + return err + } + + err = changeBootOrder(client, []string{"Intel(r) AMT: Force PXE Boot"}) + if err != nil { + return err + } + + return nil +} + +func getBootConfigSettingRef(client *Client, name string) (*dom.Element, error) { + return getEndpointReferenceByInstanceID(client, resourceCIMBootConfigSetting, name) +} + +func getBootSourceRef(client *Client, name string) (*dom.Element, error) { + return getEndpointReferenceByInstanceID(client, resourceCIMBootSourceSetting, name) +} diff --git a/bootconfigrole_string.go b/bootconfigrole_string.go new file mode 100644 index 0000000..6a57004 --- /dev/null +++ b/bootconfigrole_string.go @@ -0,0 +1,36 @@ +// Code generated by "stringer -type=bootConfigRole -trimprefix=bootConfigRole -linecomment"; DO NOT EDIT. + +package amt + +import "strconv" + +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[bootConfigRoleIsNext-0] + _ = x[bootConfigRoleIsNextSingleUse-1] + _ = x[bootConfigRoleIsDefault-2] + _ = x[bootConfigRoleDMTFReserved-3] + _ = x[bootConfigRoleVendorSpecified-32768] +} + +const ( + _bootConfigRole_name_0 = "IsNextIsNextSingleUseIsDefault3..32767" + _bootConfigRole_name_1 = "32768..65535" +) + +var ( + _bootConfigRole_index_0 = [...]uint8{0, 6, 21, 30, 38} +) + +func (i bootConfigRole) String() string { + switch { + case 0 <= i && i <= 3: + return _bootConfigRole_name_0[_bootConfigRole_index_0[i]:_bootConfigRole_index_0[i+1]] + case i == 32768: + return _bootConfigRole_name_1 + default: + return "bootConfigRole(" + strconv.FormatInt(int64(i), 10) + ")" + } +} diff --git a/cim.go b/cim.go new file mode 100644 index 0000000..ea8311b --- /dev/null +++ b/cim.go @@ -0,0 +1,75 @@ +package amt + +import ( + "fmt" + "strconv" + + "github.com/VictorLowther/simplexml/dom" + "github.com/VictorLowther/simplexml/search" + "github.com/ammmze/wsman" +) + +const ( + resourceCIMAssociatedPowerManagementService = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AssociatedPowerManagementService" + resourceCIMBootConfigSetting = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_BootConfigSetting" + resourceCIMBootService = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_BootService" + resourceCIMBootSourceSetting = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_BootSourceSetting" + resourceCIMPowerManagementService = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PowerManagementService" + resourceCIMComputerSystem = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem" +) + +func getEndpointReferenceBySelector(client *Client, namespace string, selectorName string, selectorValue string) (*dom.Element, error) { + message := client.wsManClient.EnumerateEPR(namespace) + + response, err := message.Send() + if err != nil { + return nil, err + } + items, err := response.EnumItems() + if err != nil { + return nil, err + } + + for _, item := range items { + selector := search.First(search.Attr("Name", "*", selectorName), item.Descendants()) + if selector == nil || string(selector.Content) != selectorValue { + continue + } + return item, nil + } + return nil, fmt.Errorf("could not find endpoint reference with selector %s=%s", selectorName, selectorValue) +} + +func getEndpointReferenceByInstanceID(client *Client, namespace string, instanceID string) (*dom.Element, error) { + return getEndpointReferenceBySelector(client, namespace, "InstanceID", instanceID) +} + +func getComputerSystemRef(client *Client, name string) (*dom.Element, error) { + return getEndpointReferenceBySelector(client, resourceCIMComputerSystem, "Name", name) +} + +func getReturnValueInt(response *wsman.Message) (int, error) { + returnElement := search.FirstTag("ReturnValue", "*", response.AllBodyElements()) + if returnElement == nil { + return -1, fmt.Errorf("no ReturnValue found in the response") + } + return strconv.Atoi(string(returnElement.Content)) +} + +func sendMessageForReturnValueInt(message *wsman.Message) (int, error) { + response, err := message.Send() + if err != nil { + return -1, err + } + returnValue, err := getReturnValueInt(response) + + if err != nil { + return -1, err + } + + if returnValue == 0 { + return returnValue, nil + } + + return returnValue, fmt.Errorf("received invalid return value %d", returnValue) +} diff --git a/client.go b/client.go new file mode 100644 index 0000000..ef72b7f --- /dev/null +++ b/client.go @@ -0,0 +1,63 @@ +package amt + +import ( + "fmt" + + "github.com/ammmze/wsman" +) + +// Client used to perform actions on the machine +type Client struct { + wsManClient *wsman.Client +} + +// NewClient creates an amt client to use. +func NewClient(connection Connection) (*Client, error) { + port := int(connection.Port) + if port == 0 { + port = 16992 + } + path := connection.Path + if path == "" { + path = "/wsman" + } + target := fmt.Sprintf("http://%s:%d%s", connection.Host, port, path) + wsmanClient, err := wsman.NewClient(target, connection.User, connection.Pass, true) + if err != nil { + return nil, err + } + wsmanClient.Debug = connection.Debug + return &Client{ + wsManClient: wsmanClient, + }, nil +} + +// Close the client. +func (c *Client) Close() error { + return nil +} + +// PowerOn will power on a given machine. +func (c *Client) PowerOn() error { + return powerOn(c) +} + +// PowerOff will power off a given machine. +func (c *Client) PowerOff() error { + return powerOff(c) +} + +// PowerCycle will power cycle a given machine. +func (c *Client) PowerCycle() error { + return powerCycle(c) +} + +// SetPXE makes sure the node will pxe boot next time. +func (c *Client) SetPXE() error { + return setPXE(c) +} + +// IsPoweredOn checks current power state. +func (c *Client) IsPoweredOn() (bool, error) { + return isPoweredOn(c) +} diff --git a/connection.go b/connection.go new file mode 100644 index 0000000..4a63e21 --- /dev/null +++ b/connection.go @@ -0,0 +1,11 @@ +package amt + +// Connection properties for a Client +type Connection struct { + Host string + Port int + Path string + User string + Pass string + Debug bool +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..f5b9d4a --- /dev/null +++ b/go.mod @@ -0,0 +1,22 @@ +module github.com/ammmze/go-amt + +go 1.17 + +require ( + github.com/VictorLowther/simplexml v0.0.0-20180716164440-0bff93621230 + github.com/ammmze/wsman v0.0.2 + github.com/stretchr/testify v1.7.0 + golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 + golang.org/x/tools v0.1.8 +) + +require ( + github.com/VictorLowther/soap v0.0.0-20150314151524-8e36fca84b22 // indirect + github.com/davecgh/go-spew v1.1.0 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/satori/go.uuid v1.2.0 // indirect + golang.org/x/mod v0.5.1 // indirect + golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect + golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect + gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..872b591 --- /dev/null +++ b/go.sum @@ -0,0 +1,58 @@ +github.com/VictorLowther/simplexml v0.0.0-20180716164440-0bff93621230 h1:t95Grn2mOPfb3+kPDWsNnj4dlNcxnvuR72IjY8eYjfQ= +github.com/VictorLowther/simplexml v0.0.0-20180716164440-0bff93621230/go.mod h1:t2EzW1qybnPDQ3LR/GgeF0GOzHUXT5IVMLP2gkW1cmc= +github.com/VictorLowther/soap v0.0.0-20150314151524-8e36fca84b22 h1:a0MBqYm44o0NcthLKCljZHe1mxlN6oahCQHHThnSwB4= +github.com/VictorLowther/soap v0.0.0-20150314151524-8e36fca84b22/go.mod h1:/B7V22rcz4860iDqstGvia/2+IYWXf3/JdQCVd/1D2A= +github.com/ammmze/wsman v0.0.2 h1:5bxOFw1OXBIff6OxXfVmCSkV8sxOjQLFpUimev/oCj0= +github.com/ammmze/wsman v0.0.2/go.mod h1:TJdzGFrJZfTvF3Mu+tCLrXqap5/75eqPVguHUXbYoHA= +github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww= +github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 h1:VLliZ0d+/avPrXXH+OakdXhpJuEoBZuwh1m2j7U6Iug= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38= +golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.1.8 h1:P1HhGGuLW4aAclzjtmJdf0mJOjVUZUzOTqkAkWL+l6w= +golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/power.go b/power.go new file mode 100644 index 0000000..df7c3b5 --- /dev/null +++ b/power.go @@ -0,0 +1,256 @@ +//go:generate stringer -type=powerState -trimprefix=powerState -linecomment + +package amt + +import ( + "log" + "fmt" + "strconv" + + "github.com/VictorLowther/simplexml/dom" + "github.com/ammmze/wsman" +) + +type powerState int + +// https://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide/HTMLDocuments/WS-Management_Class_Reference/CIM_AssociatedPowerManagementService.htm#powerState +// https://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide/default.htm?turl=WordDocuments%2Fgetsystempowerstate.htm +const ( + powerStateUnknown powerState = 0 + powerStateOther powerState = 1 + powerStateOn powerState = 2 + powerStateSleepLight powerState = 3 + powerStateSleepDeep powerState = 4 + powerStatePowerCycleOffSoft powerState = 5 + powerStateOffHard powerState = 6 + powerStateHibernateOffSoft powerState = 7 + powerStateOffSoft powerState = 8 + powerStatePowerCycleOffHard powerState = 9 + powerStateMasterBusReset powerState = 10 + powerStateDiagnosticInterruptNMI powerState = 11 + powerStateOffSoftGraceful powerState = 12 + powerStateOffHardGraceful powerState = 13 + powerStateMasterBusResetGraceful powerState = 14 + powerStatePowerCycleOffSoftGraceful powerState = 15 + powerStatePowerCycleOffHardGraceful powerState = 16 + powerStateDiagnosticInterruptInit powerState = 17 + // DMTF Reserverd = .. + // Vendor Specific = 0x7FFF..0xFFFF +) + +type powerStatus struct { + AvailableRequestedpowerStates []powerState + powerState powerState + RequestedpowerState powerState +} + +func getPowerStatus(client *Client) (*powerStatus, error) { + // https://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide/default.htm?turl=WordDocuments%2Fgetsystempowerstate.htm + message := client.wsManClient.Enumerate(resourceCIMAssociatedPowerManagementService) + + response, err := message.Send() + if err != nil { + return nil, err + } + pmElms, err := getPowerManagementElements(response) + if err != nil { + return nil, err + } + + status := &powerStatus{ + AvailableRequestedpowerStates: []powerState{}, + } + for _, e := range pmElms { + switch e.Name.Local { + case "PowerState": + val, err := strconv.Atoi(string(e.Content)) + if err != nil { + return nil, err + } + status.powerState = powerState(val) + case "RequestedPowerState": + val, err := strconv.Atoi(string(e.Content)) + if err != nil { + return nil, err + } + status.RequestedpowerState = powerState(val) + case "AvailableRequestedPowerStates": + val, err := strconv.Atoi(string(e.Content)) + if err != nil { + return nil, err + } + status.AvailableRequestedpowerStates = append(status.AvailableRequestedpowerStates, powerState(val)) + } + } + + return status, nil +} + +func powerOn(client *Client) error { + isOn, err := isPoweredOn(client) + if err != nil { + return err + } + if isOn { + return nil + } + _, err = requestpowerState(client, powerStateOn) + return err +} + +func powerOff(client *Client) error { + status, err := getPowerStatus(client) + if err != nil { + return err + } + if isPoweredOnGivenStatus(status) { + request := selectNextState(getPowerOffStates(), status.AvailableRequestedpowerStates) + + if request != powerStateUnknown { + _, err := requestpowerState(client, request) + return err + } + return fmt.Errorf("there is no implemented transition state to power off the machine from the current machine state %d. available states are: %v", status.powerState, status.AvailableRequestedpowerStates) + } + return nil +} + +func powerCycle(client *Client) error { + status, err := getPowerStatus(client) + if err != nil { + return err + } + + if !isPoweredOnGivenStatus(status) { + return powerOn(client) + } + + request := selectNextState(getPowerCycleStates(), status.AvailableRequestedpowerStates) + + if request >= 0 { + _, err := requestpowerState(client, request) + return err + } + + return fmt.Errorf("there is no implemented transition state to power cycle the machine from the current machine state %d. available states are: %v", status.powerState, status.AvailableRequestedpowerStates) +} + +func isPoweredOn(client *Client) (bool, error) { + status, err := getPowerStatus(client) + if err != nil { + return false, err + } + return isPoweredOnGivenStatus(status), nil +} + +func isPoweredOnGivenStatus(status *powerStatus) bool { + log.Printf("Current state: %s; Available states: %s\n", status.powerState, status.AvailableRequestedpowerStates) + switch status.powerState { + case powerStateOn: + return true + default: + return false + } +} + +// https://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide/default.htm?turl=WordDocuments%2Fchangesystempowerstate.htm +func requestpowerState(client *Client, requestedpowerState powerState) (int, error) { + status, err := getPowerStatus(client) + if err != nil { + return -1, err + } + if !containspowerState(status.AvailableRequestedpowerStates, requestedpowerState) { + // fmt.Printf("there is no implemented transition state to <%d> from the current machine state <%d>. available states are: %v\n", requestedpowerState, status.powerState, status.AvailableRequestedpowerStates) + return -1, fmt.Errorf("there is no implemented transition state to <%d> from the current machine state <%d>. available states are: %v", requestedpowerState, status.powerState, status.AvailableRequestedpowerStates) + } + fmt.Printf("sending request to machine: <%s>\n", requestedpowerState) + message := client.wsManClient.Invoke(resourceCIMPowerManagementService, "RequestPowerStateChange") + message.Parameters("PowerState", fmt.Sprint(int(requestedpowerState))) + managedElement, err := makeManagedElement(client, message) + if err != nil { + return -1, err + } + message.AddParameter(managedElement) + + response, err := message.Send() + if err != nil { + return -1, err + } + + body := response.GetBody(dom.Elem("RequestPowerStateChange_OUTPUT", resourceCIMPowerManagementService)) + if body == nil || len(body.Children()) != 1 { + return -1, fmt.Errorf("received unknown response requesting power state change: %v", response) + } + val, err := strconv.Atoi(string(body.Children()[0].Content)) + if err != nil { + return -1, err + } + fmt.Printf("RequestPowerState response <%d>\n", val) + return val, nil +} + +func getPowerManagementElements(response *wsman.Message) ([]*dom.Element, error) { + items, err := response.EnumItems() + + if err != nil { + return nil, err + } + + for _, e := range items { + if e.Name.Local == "CIM_AssociatedPowerManagementService" && e.Name.Space == resourceCIMAssociatedPowerManagementService { + return e.Children(), nil + } + } + return nil, fmt.Errorf("did not receive %s enumeration item", "CIM_AssociatedPowerManagementService") +} + +func makeManagedElement(client *Client, message *wsman.Message) (*dom.Element, error) { + managedSystemRef, err := getComputerSystemRef(client, "ManagedSystem") + if err != nil { + return nil, err + } + if managedSystemRef == nil { + return nil, fmt.Errorf("could not retrieve the managed system endpoint reference") + } + managedElement := message.MakeParameter("ManagedElement") + managedElement.AddChildren(managedSystemRef.Children()...) + return managedElement, nil +} + +func getPowerOffStates() []powerState { + return []powerState{ + powerStateOffSoftGraceful, + powerStateOffSoft, + powerStateOffHardGraceful, + powerStateOffHard, + } +} + +func getPowerCycleStates() []powerState { + return []powerState{ + powerStatePowerCycleOffSoftGraceful, + powerStatePowerCycleOffSoft, + powerStateMasterBusResetGraceful, + powerStatePowerCycleOffHardGraceful, + powerStatePowerCycleOffHard, + powerStateMasterBusReset, + } +} + +func selectNextState(requestedStates []powerState, availableStates []powerState) powerState { + for _, a := range requestedStates { + if containspowerState(availableStates, a) { + return a + } + } + return powerStateUnknown +} + +func containspowerState(s []powerState, e powerState) bool { + for _, a := range s { + if a == e { + return true + } + } + return false +} diff --git a/power_test.go b/power_test.go new file mode 100644 index 0000000..2e57f58 --- /dev/null +++ b/power_test.go @@ -0,0 +1,37 @@ +package amt + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestSelectNextState_When_NoneOfTheRequestedStatesAreAvailable_Expect_Unknown(t *testing.T) { + availableStates := []powerState{powerStateOn} + nextState := selectNextState(getPowerOffStates(), availableStates) + assert.Equal(t, powerStateUnknown, nextState) +} + +func TestSelectNextState_When_OneOfTheRequestedStatesAreAvailable_Expect_RequestedState(t *testing.T) { + requestedStates := getPowerOffStates() + availableStates := []powerState{requestedStates[0]} + nextState := selectNextState(requestedStates, availableStates) + assert.Equal(t, requestedStates[0], nextState) +} +func TestSelectNextState_When_MultipleOfTheRequestedStatesAreAvailable_Expect_FirstAvailableRequestedState(t *testing.T) { + requestedStates := getPowerOffStates() + availableStates := []powerState{requestedStates[1], requestedStates[2]} + nextState := selectNextState(requestedStates, availableStates) + assert.Equal(t, requestedStates[1], nextState) +} + +func TestIsPoweredOnGivenStatus_When_powerStateOn_Expect_True(t *testing.T) { + status := &powerStatus{powerState: powerStateOn} + actual := isPoweredOnGivenStatus(status) + assert.Equal(t, true, actual) +} +func TestIsPoweredOnGivenStatus_When_powerStateOffSoft_Expect_False(t *testing.T) { + status := &powerStatus{powerState: powerStateOffSoft} + actual := isPoweredOnGivenStatus(status) + assert.Equal(t, false, actual) +} diff --git a/powerstate_string.go b/powerstate_string.go new file mode 100644 index 0000000..eab1339 --- /dev/null +++ b/powerstate_string.go @@ -0,0 +1,40 @@ +// Code generated by "stringer -type=powerState -trimprefix=powerState -linecomment"; DO NOT EDIT. + +package amt + +import "strconv" + +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[powerStateUnknown-0] + _ = x[powerStateOther-1] + _ = x[powerStateOn-2] + _ = x[powerStateSleepLight-3] + _ = x[powerStateSleepDeep-4] + _ = x[powerStatePowerCycleOffSoft-5] + _ = x[powerStateOffHard-6] + _ = x[powerStateHibernateOffSoft-7] + _ = x[powerStateOffSoft-8] + _ = x[powerStatePowerCycleOffHard-9] + _ = x[powerStateMasterBusReset-10] + _ = x[powerStateDiagnosticInterruptNMI-11] + _ = x[powerStateOffSoftGraceful-12] + _ = x[powerStateOffHardGraceful-13] + _ = x[powerStateMasterBusResetGraceful-14] + _ = x[powerStatePowerCycleOffSoftGraceful-15] + _ = x[powerStatePowerCycleOffHardGraceful-16] + _ = x[powerStateDiagnosticInterruptInit-17] +} + +const _powerState_name = "UnknownOtherOnSleepLightSleepDeepPowerCycleOffSoftOffHardHibernateOffSoftOffSoftPowerCycleOffHardMasterBusResetDiagnosticInterruptNMIOffSoftGracefulOffHardGracefulMasterBusResetGracefulPowerCycleOffSoftGracefulPowerCycleOffHardGracefulDiagnosticInterruptInit" + +var _powerState_index = [...]uint16{0, 7, 12, 14, 24, 33, 50, 57, 73, 80, 97, 111, 133, 148, 163, 185, 210, 235, 258} + +func (i powerState) String() string { + if i < 0 || i >= powerState(len(_powerState_index)-1) { + return "powerState(" + strconv.FormatInt(int64(i), 10) + ")" + } + return _powerState_name[_powerState_index[i]:_powerState_index[i+1]] +} diff --git a/tools.go b/tools.go new file mode 100644 index 0000000..1f94042 --- /dev/null +++ b/tools.go @@ -0,0 +1,8 @@ +//go:build tools + +package amt + +import ( + _ "golang.org/x/lint/golint" + _ "golang.org/x/tools/cmd/stringer" +)