src/go.chromium.org/chromiumos/test/servod/cmd/cros-servod/main.go - chromiumos/platform/dev-util - Git at Google

 // Copyright 2021 The ChromiumOS Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // Package main implements the cros-servod for starting/stopping servod daemon
 // and sending commands to it to control and test DUTs via servo hardware by
 // simulating user actions such as power on/off, flashing of firmware/OS,
 // screen close, etc.
 package main

 import (
 	"context"
 	"flag"
 	"fmt"
 	"io"
 	"log"
 	"os"
 	"path/filepath"
 	"strings"
 	"time"

 	"go.chromium.org/chromiumos/test/servod/cmd/commandexecutor"
 	"go.chromium.org/chromiumos/test/servod/cmd/model"
 	"go.chromium.org/chromiumos/test/servod/cmd/servodserver"

 	"go.chromium.org/luci/common/errors"
 )

 const (
 	// version is the version info of this command. It is filled in during emerge.
 	version         = "<unknown>"
 	helpDescription = `cros-servod tool

 The tool provides the ability to start/stop a servod Docker container either on the same host or a remote servo host and execute servod commands on it.
 go/cros-servod-design to learn more about the design.

 Commands:
   cli       Runs the server in CLI mode, executes one of the subcommands (start_servod, stop_servod, exec_cmd, call_servod) by using the input parameters and prints the result to the output file.
             Usage:
             To start servod:
             cros-servod cli start_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --servod_docker_image_path <servod_docker_image_path> --servod_port <servod_port> --board <board> --model <model> --serial_name <serial_name> --debug <debug> --recovery_mode <recovery_mode> --config <config> --allow_dual_v4 <allow_dual_v4> [--log_path /tmp/servod/]
             Example (Start non-containerized servod):
             cros-servod cli start_servod --servo_host_path localhost:9876 --servod_port 9901 --board dedede --model galith --serial_name G1911050826
             Example (Start containerized servod):
             cros-servod cli start_servod --servo_host_path localhost:9876 --servod_docker_container_name servod_container1 --servod_docker_image_path gcr.io/chromeos-bot/servod@sha256:2d25f6313c7bbac349607 --servod_port 9901 --board dedede --model galith --serial_name G1911050826

             To stop servod:
             cros-servod cli stop_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --servod_port <servod_port> [--log_path /tmp/servod/]
             Example (Stop non-containerized servod):
             cros-servod cli stop_servod --servo_host_path localhost:9876 --servod_port 9901
             Example (Stop containerized servod):
             cros-servod cli stop_servod --servo_host_path localhost:9876 --servod_docker_container_name servod_container1 --servod_port 9901

             To execute command:
             cros-servod cli exec_cmd --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --command <command> [--log_path /tmp/servod/]
             Example (Execute fake disconnect command on non-containerized servod):
             cros-servod cli exec_cmd --servo_host_path localhost:9876 --command "dut-control -p 9901 servo_v4_uart_cmd:'fakedisconnect 130 2400'"
             Example (Execute system command on containerized servod):
             cros-servod cli exec_cmd --servo_host_path localhost:9876 --servod_docker_container_name servod_container1 --command "ps -ef | grep servod"

             To call servod for doc:
             cros-servod cli call_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --method doc --args <args> [--log_path /tmp/servod/]
             Example (Call DOC method for lid_open control on non-containerized servod):
             cros-servod cli call_servod --servo_host_path localhost:9876 --method doc --args lid_open

             To call servod for get:
             cros-servod cli call_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --method get --args <args> [--log_path /tmp/servod/]
             Example (Call GET method for lid_open control on non-containerized servod):
             cros-servod cli call_servod --servo_host_path localhost:9876 --method get --args lid_open

             To call servod for set:
             cros-servod cli call_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --method set --args <args> [--log_path /tmp/servod/]
             Example (Call SET method to set lid_open control value to yes on containerized servod):
             cros-servod cli call_servod --servo_host_path localhost:9876 --servod_docker_container_name servod_container1 --method set --args "lid_open:yes"
             Example (Call SET method to execute fake disconnect on non-containerized servod):
             cros-servod cli call_servod --servo_host_path localhost:9876 --method set --args "servo_v4_uart_cmd:'fakedisconnect 130 2400'"

   server    Starts the servod server for RPC calls. Mostly used for tests.
             Usage:
             cros-servod server [--log_path /tmp/servod/] [--server_port 80]

   --version Prints the version.

   --help    Prints the help.`
 	defaultLogDirectory = "/tmp/servod/"
 	defaultServerPort   = 80
 	defaultServodPort   = 9999
 )

 // createLogFile creates a file and its parent directory for logging purpose.
 func createLogFile(logPath string) (*os.File, error) {
 	t := time.Now()
 	fullPath := filepath.Join(logPath, t.Format("20060102-150405"))
 	if err := os.MkdirAll(fullPath, 0755); err != nil {
 		return nil, fmt.Errorf("failed to create directory %v: %v", fullPath, err)
 	}

 	logFullPathName := filepath.Join(fullPath, "log.txt")

 	// Log the full output of the command to disk.
 	logFile, err := os.Create(logFullPathName)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create file %v: %v", fullPath, err)
 	}
 	return logFile, nil
 }

 // newLogger creates a logger. Using go default logger for now.
 func newLogger(logFile *os.File) *log.Logger {
 	mw := io.MultiWriter(logFile, os.Stderr)
 	return log.New(mw, "", log.LstdFlags|log.LUTC)
 }

 func runCLI(ctx context.Context, cs model.CliSubcommand, d []string) int {
 	a := model.CliArgs{}
 	fs := flag.NewFlagSet("Run servod", flag.ExitOnError)
 	fs.StringVar(&a.LogPath, "log_path", defaultLogDirectory, fmt.Sprintf("Path to record execution logs. The default value is %s", defaultLogDirectory))
 	fs.StringVar(&a.ServoHostPath, "servo_host_path", "", "The path (URI) for the servod (containerized or running as a daemon) host.")
 	fs.StringVar(&a.ServodDockerContainerName, "servod_docker_container_name", "", "The servod Docker container name.")
 	fs.StringVar(&a.ServodDockerImagePath, "servod_docker_image_path", "", "The servod Docker image path to pull from GCR.")
 	var servodPort int
 	fs.IntVar(&servodPort, "servod_port", defaultServodPort, fmt.Sprintf("The --PORT parameter value for servod command. The default value is %d.", defaultServodPort))
 	fs.StringVar(&a.Board, "board", "", "The --BOARD parameter value for servod command.")
 	fs.StringVar(&a.Model, "model", "", "The --MODEL parameter value for servod command.")
 	fs.StringVar(&a.SerialName, "serial_name", "", "The --SERIALNAME parameter value for servod command.")
 	fs.StringVar(&a.Debug, "debug", "", "The --DEBUG parameter value for servod command.")
 	fs.StringVar(&a.RecoveryMode, "recovery_mode", "", "The --RECOVERY_MODE parameter value for servod command.")
 	fs.StringVar(&a.Config, "config", "", "The --CONFIG parameter value for servod command.")
 	fs.StringVar(&a.AllowDualV4, "allow_dual_v4", "", "The --ALLOW-DUAL-V4 parameter value for servod command.")
 	fs.StringVar(&a.Command, "command", "", "The command to execute inside the servod Docker container.")
 	fs.StringVar(&a.Method, "method", "", "The method to call. Accepted values are doc, get, and set.")
 	fs.StringVar(&a.Args, "args", "", "The arguments to pass to the method.")
 	fs.Parse(d)
 	a.ServodPort = int32(servodPort)

 	logFile, err := createLogFile(a.LogPath)
 	if err != nil {
 		log.Fatalln("Failed to create log file", err)
 		return 2
 	}
 	defer logFile.Close()

 	logger := newLogger(logFile)
 	commandexecutor := commandexecutor.NewServodCommandExecutor(logger)

 	servodService, destructor, err := servodserver.NewServodService(ctx, logger, commandexecutor)
 	defer destructor()
 	if err != nil {
 		logger.Fatalln("Failed to create servod service: ", err)
 		return 2
 	}

 	if _, _, err := servodService.RunCli(cs, a, nil, true); err != nil {
 		logger.Fatalln("Failed to run CLI: ", err)
 		return 1
 	}
 	return 0
 }

 func startServer(ctx context.Context, d []string) int {
 	a := model.CliArgs{}
 	fs := flag.NewFlagSet("Start servod server", flag.ExitOnError)
 	fs.StringVar(&a.LogPath, "log_path", defaultLogDirectory, fmt.Sprintf("The path to record execution logs. The default value is %s", defaultLogDirectory))
 	var serverPort int
 	fs.IntVar(&serverPort, "server_port", defaultServerPort, fmt.Sprintf("The port for the servod GRPC server. The default value is %d.", defaultServerPort))
 	fs.Parse(d)
 	a.ServerPort = int32(serverPort)

 	logFile, err := createLogFile(a.LogPath)
 	if err != nil {
 		log.Fatalln("Failed to create log file", err)
 		return 2
 	}
 	defer logFile.Close()

 	logger := newLogger(logFile)
 	commandexecutor := commandexecutor.NewServodCommandExecutor(logger)

 	servodService, destructor, err := servodserver.NewServodService(ctx, logger, commandexecutor)
 	defer destructor()
 	if err != nil {
 		logger.Fatalln("Failed to create servod service: ", err)
 		return 2
 	}

 	if err := servodService.StartServer(a.ServerPort); err != nil {
 		logger.Fatalln("Failed to start servod server: ", err)
 		return 1
 	}
 	return 0
 }

 // Specify run mode for cros-servod.
 type runMode string

 const (
 	runCli     runMode = "cli"
 	runServer  runMode = "server"
 	runVersion runMode = "version"
 	runHelp    runMode = "help"
 )

 func getRunMode() (runMode, error) {
 	if len(os.Args) > 1 {
 		for _, a := range os.Args {
 			if a == "--version" {
 				return runVersion, nil
 			}
 		}
 		switch strings.ToLower(os.Args[1]) {
 		case "cli":
 			return runCli, nil
 		case "server":
 			return runServer, nil
 		}
 	}
 	// If we did not find special run mode then just print help for user.
 	return runHelp, nil
 }

 func getCliSubcommand() (model.CliSubcommand, error) {
 	if len(os.Args) > 2 {
 		switch strings.ToLower(os.Args[2]) {
 		case "start_servod":
 			return model.CliStartServod, nil
 		case "stop_servod":
 			return model.CliStopServod, nil
 		case "exec_cmd":
 			return model.CliExecCmd, nil
 		case "call_servod":
 			return model.CliCallServod, nil
 		}
 	}
 	return model.CliUnknown, errors.Reason("Unknown CLI subcommand").Err()
 }

 func mainInternal() int {
 	rm, err := getRunMode()
 	if err != nil {
 		log.Fatalln(err)
 		return 2
 	}

 	ctx := context.Background()
 	switch rm {
 	case runCli:
 		log.Printf("Running CLI mode!")
 		cs, err := getCliSubcommand()
 		if err != nil {
 			log.Fatalln(err)
 			return 2
 		}
 		return runCLI(ctx, cs, os.Args[3:])
 	case runServer:
 		log.Printf("Running server mode!")
 		return startServer(ctx, os.Args[2:])
 	case runVersion:
 		log.Printf("cros-servod version: %s", version)
 		return 0
 	}

 	log.Println(helpDescription)
 	return 0
 }

 func main() {
 	os.Exit(mainInternal())
 }
	// Copyright 2021 The ChromiumOS Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// Package main implements the cros-servod for starting/stopping servod daemon
	// and sending commands to it to control and test DUTs via servo hardware by
	// simulating user actions such as power on/off, flashing of firmware/OS,
	// screen close, etc.
	package main

	import (
	"context"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"strings"
	"time"

	"go.chromium.org/chromiumos/test/servod/cmd/commandexecutor"
	"go.chromium.org/chromiumos/test/servod/cmd/model"
	"go.chromium.org/chromiumos/test/servod/cmd/servodserver"

	"go.chromium.org/luci/common/errors"
	)

	const (
	// version is the version info of this command. It is filled in during emerge.
	version = "<unknown>"
	helpDescription = `cros-servod tool

	The tool provides the ability to start/stop a servod Docker container either on the same host or a remote servo host and execute servod commands on it.
	go/cros-servod-design to learn more about the design.

	Commands:
	cli Runs the server in CLI mode, executes one of the subcommands (start_servod, stop_servod, exec_cmd, call_servod) by using the input parameters and prints the result to the output file.
	Usage:
	To start servod:
	cros-servod cli start_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --servod_docker_image_path <servod_docker_image_path> --servod_port <servod_port> --board <board> --model <model> --serial_name <serial_name> --debug <debug> --recovery_mode <recovery_mode> --config <config> --allow_dual_v4 <allow_dual_v4> [--log_path /tmp/servod/]
	Example (Start non-containerized servod):
	cros-servod cli start_servod --servo_host_path localhost:9876 --servod_port 9901 --board dedede --model galith --serial_name G1911050826
	Example (Start containerized servod):
	cros-servod cli start_servod --servo_host_path localhost:9876 --servod_docker_container_name servod_container1 --servod_docker_image_path gcr.io/chromeos-bot/servod@sha256:2d25f6313c7bbac349607 --servod_port 9901 --board dedede --model galith --serial_name G1911050826

	To stop servod:
	cros-servod cli stop_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --servod_port <servod_port> [--log_path /tmp/servod/]
	Example (Stop non-containerized servod):
	cros-servod cli stop_servod --servo_host_path localhost:9876 --servod_port 9901
	Example (Stop containerized servod):
	cros-servod cli stop_servod --servo_host_path localhost:9876 --servod_docker_container_name servod_container1 --servod_port 9901

	To execute command:
	cros-servod cli exec_cmd --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --command <command> [--log_path /tmp/servod/]
	Example (Execute fake disconnect command on non-containerized servod):
	cros-servod cli exec_cmd --servo_host_path localhost:9876 --command "dut-control -p 9901 servo_v4_uart_cmd:'fakedisconnect 130 2400'"
	Example (Execute system command on containerized servod):
	cros-servod cli exec_cmd --servo_host_path localhost:9876 --servod_docker_container_name servod_container1 --command "ps -ef \| grep servod"

	To call servod for doc:
	cros-servod cli call_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --method doc --args <args> [--log_path /tmp/servod/]
	Example (Call DOC method for lid_open control on non-containerized servod):
	cros-servod cli call_servod --servo_host_path localhost:9876 --method doc --args lid_open

	To call servod for get:
	cros-servod cli call_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --method get --args <args> [--log_path /tmp/servod/]
	Example (Call GET method for lid_open control on non-containerized servod):
	cros-servod cli call_servod --servo_host_path localhost:9876 --method get --args lid_open

	To call servod for set:
	cros-servod cli call_servod --servo_host_path <ip:port> --servod_docker_container_name <a_unique_name> --method set --args <args> [--log_path /tmp/servod/]
	Example (Call SET method to set lid_open control value to yes on containerized servod):
	cros-servod cli call_servod --servo_host_path localhost:9876 --servod_docker_container_name servod_container1 --method set --args "lid_open:yes"
	Example (Call SET method to execute fake disconnect on non-containerized servod):
	cros-servod cli call_servod --servo_host_path localhost:9876 --method set --args "servo_v4_uart_cmd:'fakedisconnect 130 2400'"

	server Starts the servod server for RPC calls. Mostly used for tests.
	Usage:
	cros-servod server [--log_path /tmp/servod/] [--server_port 80]

	--version Prints the version.

	--help Prints the help.`
	defaultLogDirectory = "/tmp/servod/"
	defaultServerPort = 80
	defaultServodPort = 9999
	)

	// createLogFile creates a file and its parent directory for logging purpose.
	func createLogFile(logPath string) (*os.File, error) {
	t := time.Now()
	fullPath := filepath.Join(logPath, t.Format("20060102-150405"))
	if err := os.MkdirAll(fullPath, 0755); err != nil {
	return nil, fmt.Errorf("failed to create directory %v: %v", fullPath, err)
	}

	logFullPathName := filepath.Join(fullPath, "log.txt")

	// Log the full output of the command to disk.
	logFile, err := os.Create(logFullPathName)
	if err != nil {
	return nil, fmt.Errorf("failed to create file %v: %v", fullPath, err)
	}
	return logFile, nil
	}

	// newLogger creates a logger. Using go default logger for now.
	func newLogger(logFile os.File) log.Logger {
	mw := io.MultiWriter(logFile, os.Stderr)
	return log.New(mw, "", log.LstdFlags\|log.LUTC)
	}

	func runCLI(ctx context.Context, cs model.CliSubcommand, d []string) int {
	a := model.CliArgs{}
	fs := flag.NewFlagSet("Run servod", flag.ExitOnError)
	fs.StringVar(&a.LogPath, "log_path", defaultLogDirectory, fmt.Sprintf("Path to record execution logs. The default value is %s", defaultLogDirectory))
	fs.StringVar(&a.ServoHostPath, "servo_host_path", "", "The path (URI) for the servod (containerized or running as a daemon) host.")
	fs.StringVar(&a.ServodDockerContainerName, "servod_docker_container_name", "", "The servod Docker container name.")
	fs.StringVar(&a.ServodDockerImagePath, "servod_docker_image_path", "", "The servod Docker image path to pull from GCR.")
	var servodPort int
	fs.IntVar(&servodPort, "servod_port", defaultServodPort, fmt.Sprintf("The --PORT parameter value for servod command. The default value is %d.", defaultServodPort))
	fs.StringVar(&a.Board, "board", "", "The --BOARD parameter value for servod command.")
	fs.StringVar(&a.Model, "model", "", "The --MODEL parameter value for servod command.")
	fs.StringVar(&a.SerialName, "serial_name", "", "The --SERIALNAME parameter value for servod command.")
	fs.StringVar(&a.Debug, "debug", "", "The --DEBUG parameter value for servod command.")
	fs.StringVar(&a.RecoveryMode, "recovery_mode", "", "The --RECOVERY_MODE parameter value for servod command.")
	fs.StringVar(&a.Config, "config", "", "The --CONFIG parameter value for servod command.")
	fs.StringVar(&a.AllowDualV4, "allow_dual_v4", "", "The --ALLOW-DUAL-V4 parameter value for servod command.")
	fs.StringVar(&a.Command, "command", "", "The command to execute inside the servod Docker container.")
	fs.StringVar(&a.Method, "method", "", "The method to call. Accepted values are doc, get, and set.")
	fs.StringVar(&a.Args, "args", "", "The arguments to pass to the method.")
	fs.Parse(d)
	a.ServodPort = int32(servodPort)

	logFile, err := createLogFile(a.LogPath)
	if err != nil {
	log.Fatalln("Failed to create log file", err)
	return 2
	}
	defer logFile.Close()

	logger := newLogger(logFile)
	commandexecutor := commandexecutor.NewServodCommandExecutor(logger)

	servodService, destructor, err := servodserver.NewServodService(ctx, logger, commandexecutor)
	defer destructor()
	if err != nil {
	logger.Fatalln("Failed to create servod service: ", err)
	return 2
	}

	if _, _, err := servodService.RunCli(cs, a, nil, true); err != nil {
	logger.Fatalln("Failed to run CLI: ", err)
	return 1
	}
	return 0
	}

	func startServer(ctx context.Context, d []string) int {
	a := model.CliArgs{}
	fs := flag.NewFlagSet("Start servod server", flag.ExitOnError)
	fs.StringVar(&a.LogPath, "log_path", defaultLogDirectory, fmt.Sprintf("The path to record execution logs. The default value is %s", defaultLogDirectory))
	var serverPort int
	fs.IntVar(&serverPort, "server_port", defaultServerPort, fmt.Sprintf("The port for the servod GRPC server. The default value is %d.", defaultServerPort))
	fs.Parse(d)
	a.ServerPort = int32(serverPort)

	logFile, err := createLogFile(a.LogPath)
	if err != nil {
	log.Fatalln("Failed to create log file", err)
	return 2
	}
	defer logFile.Close()

	logger := newLogger(logFile)
	commandexecutor := commandexecutor.NewServodCommandExecutor(logger)

	servodService, destructor, err := servodserver.NewServodService(ctx, logger, commandexecutor)
	defer destructor()
	if err != nil {
	logger.Fatalln("Failed to create servod service: ", err)
	return 2
	}

	if err := servodService.StartServer(a.ServerPort); err != nil {
	logger.Fatalln("Failed to start servod server: ", err)
	return 1
	}
	return 0
	}

	// Specify run mode for cros-servod.
	type runMode string

	const (
	runCli runMode = "cli"
	runServer runMode = "server"
	runVersion runMode = "version"
	runHelp runMode = "help"
	)

	func getRunMode() (runMode, error) {
	if len(os.Args) > 1 {
	for _, a := range os.Args {
	if a == "--version" {
	return runVersion, nil
	}
	}
	switch strings.ToLower(os.Args[1]) {
	case "cli":
	return runCli, nil
	case "server":
	return runServer, nil
	}
	}
	// If we did not find special run mode then just print help for user.
	return runHelp, nil
	}

	func getCliSubcommand() (model.CliSubcommand, error) {
	if len(os.Args) > 2 {
	switch strings.ToLower(os.Args[2]) {
	case "start_servod":
	return model.CliStartServod, nil
	case "stop_servod":
	return model.CliStopServod, nil
	case "exec_cmd":
	return model.CliExecCmd, nil
	case "call_servod":
	return model.CliCallServod, nil
	}
	}
	return model.CliUnknown, errors.Reason("Unknown CLI subcommand").Err()
	}

	func mainInternal() int {
	rm, err := getRunMode()
	if err != nil {
	log.Fatalln(err)
	return 2
	}

	ctx := context.Background()
	switch rm {
	case runCli:
	log.Printf("Running CLI mode!")
	cs, err := getCliSubcommand()
	if err != nil {
	log.Fatalln(err)
	return 2
	}
	return runCLI(ctx, cs, os.Args[3:])
	case runServer:
	log.Printf("Running server mode!")
	return startServer(ctx, os.Args[2:])
	case runVersion:
	log.Printf("cros-servod version: %s", version)
	return 0
	}

	log.Println(helpDescription)
	return 0
	}

	func main() {
	os.Exit(mainInternal())
	}