158 lines
3.5 KiB
Go
158 lines
3.5 KiB
Go
package bootcommand
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// KeysAction represents what we want to do with a key press.
|
|
// It can take 3 states. We either want to:
|
|
// * press the key once
|
|
// * press and hold
|
|
// * press and release
|
|
type KeyAction int
|
|
|
|
const (
|
|
KeyOn KeyAction = 1 << iota
|
|
KeyOff
|
|
KeyPress
|
|
)
|
|
|
|
func (k KeyAction) String() string {
|
|
switch k {
|
|
case KeyOn:
|
|
return "On"
|
|
case KeyOff:
|
|
return "Off"
|
|
case KeyPress:
|
|
return "Press"
|
|
}
|
|
panic(fmt.Sprintf("Unknwon KeyAction %d", k))
|
|
}
|
|
|
|
type expression interface {
|
|
// Do executes the expression
|
|
Do(context.Context, BCDriver) error
|
|
// Validate validates the expression without executing it
|
|
Validate() error
|
|
}
|
|
|
|
type expressionSequence []expression
|
|
|
|
// Do executes every expression in the sequence and then flushes remaining
|
|
// scancodes.
|
|
func (s expressionSequence) Do(ctx context.Context, b BCDriver) error {
|
|
// validate should never fail here, since it should be called before
|
|
// expressionSequence.Do. Only reason we don't panic is so we can clean up.
|
|
if errs := s.Validate(); errs != nil {
|
|
return fmt.Errorf("Found an invalid boot command. This is likely an error in Packer, so please open a ticket.")
|
|
}
|
|
|
|
for _, exp := range s {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
if err := exp.Do(ctx, b); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return b.Flush()
|
|
}
|
|
|
|
// Validate tells us if every expression in the sequence is valid.
|
|
func (s expressionSequence) Validate() (errs []error) {
|
|
for _, exp := range s {
|
|
if err := exp.Validate(); err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// GenerateExpressionSequence generates a sequence of expressions from the
|
|
// given command. This is the primary entry point to the boot command parser.
|
|
func GenerateExpressionSequence(command string) (expressionSequence, error) {
|
|
seq := expressionSequence{}
|
|
if command == "" {
|
|
return seq, nil
|
|
}
|
|
got, err := ParseReader("", strings.NewReader(command))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, exp := range got.([]interface{}) {
|
|
seq = append(seq, exp.(expression))
|
|
}
|
|
return seq, nil
|
|
}
|
|
|
|
type waitExpression struct {
|
|
d time.Duration
|
|
}
|
|
|
|
// Do waits the amount of time described by the expression. It is cancellable
|
|
// through the context.
|
|
func (w *waitExpression) Do(ctx context.Context, driver BCDriver) error {
|
|
driver.Flush()
|
|
log.Printf("[INFO] Waiting %s", w.d)
|
|
select {
|
|
case <-time.After(w.d):
|
|
return nil
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
}
|
|
}
|
|
|
|
// Validate returns an error if the time is <= 0
|
|
func (w *waitExpression) Validate() error {
|
|
if w.d <= 0 {
|
|
return fmt.Errorf("Expecting a positive wait value. Got %s", w.d)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (w *waitExpression) String() string {
|
|
return fmt.Sprintf("Wait<%s>", w.d)
|
|
}
|
|
|
|
type specialExpression struct {
|
|
s string
|
|
action KeyAction
|
|
}
|
|
|
|
// Do sends the special command to the driver, along with the key action.
|
|
func (s *specialExpression) Do(ctx context.Context, driver BCDriver) error {
|
|
return driver.SendSpecial(s.s, s.action)
|
|
}
|
|
|
|
// Validate always passes
|
|
func (s *specialExpression) Validate() error {
|
|
return nil
|
|
}
|
|
|
|
func (s *specialExpression) String() string {
|
|
return fmt.Sprintf("Spec-%s(%s)", s.action, s.s)
|
|
}
|
|
|
|
type literal struct {
|
|
s rune
|
|
action KeyAction
|
|
}
|
|
|
|
// Do sends the key to the driver, along with the key action.
|
|
func (l *literal) Do(ctx context.Context, driver BCDriver) error {
|
|
return driver.SendKey(l.s, l.action)
|
|
}
|
|
|
|
// Validate always passes
|
|
func (l *literal) Validate() error {
|
|
return nil
|
|
}
|
|
|
|
func (l *literal) String() string {
|
|
return fmt.Sprintf("LIT-%s(%s)", l.action, string(l.s))
|
|
}
|