| // Copyright 2021 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Package driver implements drivers to execute tests. |
| package driver |
| |
| import ( |
| "bufio" |
| "context" |
| "fmt" |
| "log" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "sync" |
| "time" |
| |
| "chromiumos/lro" |
| |
| "go.chromium.org/chromiumos/config/go/test/api" |
| |
| "chromiumos/test/execution/cmd/testexecserver/internal/tautoresults" |
| ) |
| |
| // TautoDriver runs Tauto and report its results. |
| type TautoDriver struct { |
| // logger provides logging service. |
| logger *log.Logger |
| |
| // Long running operation manager |
| manager *lro.Manager |
| |
| // operation name |
| op string |
| } |
| |
| // NewTautoDriver creates a new driver to run tests. |
| func NewTautoDriver(logger *log.Logger) *TautoDriver { |
| return &TautoDriver{ |
| logger: logger, |
| } |
| } |
| |
| // RunTests drives a test framework to execute tests. |
| func (td *TautoDriver) RunTests(ctx context.Context, resultsDir, dut, tlwAddr string, tests []string) (*api.RunTestsResponse, error) { |
| path := "/usr/bin/test_that" // Default path of test_that. |
| |
| if resultsDir != "" { |
| // Make sure the result directory exists. |
| if err := os.MkdirAll(resultsDir, 0755); err != nil { |
| return nil, fmt.Errorf("failed to create result directory %v", resultsDir) |
| } |
| } |
| |
| args := newTautoArgs(dut, tests, resultsDir) |
| |
| // Run RTD. |
| cmd := exec.Command(path, genTautoArgList(args)...) |
| stderr, err := cmd.StderrPipe() |
| if err != nil { |
| return nil, fmt.Errorf("StderrPipe failed") |
| } |
| stdout, err := cmd.StdoutPipe() |
| if err != nil { |
| return nil, fmt.Errorf("StdoutPipe failed") |
| } |
| if err := cmd.Start(); err != nil { |
| return nil, fmt.Errorf("failed to run Tauto: %v", err) |
| } |
| var wg sync.WaitGroup |
| wg.Add(2) |
| |
| go func() { |
| defer wg.Done() |
| scanner := bufio.NewScanner(stderr) |
| for scanner.Scan() { |
| td.logger.Printf("[tauto] %v", scanner.Text()) |
| } |
| }() |
| |
| go func() { |
| defer wg.Done() |
| scanner := bufio.NewScanner(stdout) |
| for scanner.Scan() { |
| td.logger.Printf("[tauto] %v", scanner.Text()) |
| } |
| }() |
| |
| wg.Wait() |
| |
| if err := cmd.Wait(); err != nil { |
| return nil, fmt.Errorf("fail to run tauto: %s", err) |
| } |
| |
| results, err := tautoresults.TestsReports(resultsDir, tests) |
| |
| if err != nil { |
| return &api.RunTestsResponse{}, err |
| } |
| |
| return &api.RunTestsResponse{TestCaseResults: results}, nil |
| } |
| |
| // Flag names. More to be populated once impl details are firmed. |
| const ( |
| autotestDir = "--autotest_dir" |
| tautoResultsDirFlag = "--results_dir" |
| ) |
| |
| // tautoRunArgs stores arguments to invoke tauto |
| type tautoRunArgs struct { |
| target string // The url for the target machine. |
| patterns []string // The names of test to be run. |
| runFlags map[string]string // The flags for tauto run command. |
| } |
| |
| // newTautoArgs created an argument structure for invoking tauto |
| func newTautoArgs(dut string, tests []string, resultsDir string) *tautoRunArgs { |
| args := tautoRunArgs{ |
| target: dut, |
| runFlags: map[string]string{ |
| autotestDir: "/usr/local/autotest/", |
| }, |
| } |
| |
| args.patterns = tests // TO-DO Support Tags |
| |
| if resultsDir == "" { |
| t := time.Now() |
| resultsDir = filepath.Join("/tmp/results/autotest", t.Format("20060102-150405")) |
| } |
| |
| args.runFlags[tautoResultsDirFlag] = resultsDir |
| return &args |
| } |
| |
| // genArgList generates argument list for invoking Tauto |
| func genTautoArgList(args *tautoRunArgs) (argList []string) { |
| for flag, value := range args.runFlags { |
| argList = append(argList, fmt.Sprintf("%v=%v", flag, value)) |
| } |
| argList = append(argList, args.target) |
| argList = append(argList, args.patterns...) |
| return argList |
| } |