src/chromiumos/tast/local/bundles/cros/wilco/wilco_service.go - chromiumos/platform/tast-tests - Git at Google

 // Copyright 2020 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 wilco

 import (
 	"context"
 	"syscall"
 	"time"

 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/ptypes/empty"
 	"google.golang.org/grpc"

 	"chromiumos/tast/errors"
 	"chromiumos/tast/local/bundles/cros/wilco/routines"
 	"chromiumos/tast/local/wilco"
 	wpb "chromiumos/tast/services/cros/wilco"
 	"chromiumos/tast/testing"
 	"chromiumos/tast/timing"
 	dtcpb "chromiumos/wilco_dtc"
 )

 func init() {
 	testing.AddService(&testing.Service{
 		Register: func(srv *grpc.Server, s *testing.ServiceState) {
 			wpb.RegisterWilcoServiceServer(srv, &WilcoService{s: s})
 		},
 	})
 }

 // WilcoService implements tast.cros.wilco.WilcoService.
 type WilcoService struct { // NOLINT
 	s                 *testing.ServiceState
 	receiver          *wilco.DPSLMessageReceiver
 	receiverCtxCancel func()
 }

 func (c *WilcoService) GetStatus(ctx context.Context, req *empty.Empty) (*wpb.GetStatusResponse, error) {
 	supportdPID, err := wilco.SupportdPID(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get status of the Wilco DTC Support Daemon")
 	}

 	vmPID, err := wilco.VMPID(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get status of the Wilco DTC VM")
 	}

 	if supportdPID < 0 {
 		return nil, errors.New("PID of Wilco DTC Support Daemon is negative")
 	}

 	if vmPID < 0 {
 		return nil, errors.New("PID of Wilco DTC VM is negative")
 	}

 	return &wpb.GetStatusResponse{
 		WilcoDtcSupportdPid: uint64(supportdPID),
 		WilcoDtcPid:         uint64(vmPID),
 	}, nil
 }

 func (c *WilcoService) RestartVM(ctx context.Context, req *wpb.RestartVMRequest) (*empty.Empty, error) {
 	if err := wilco.StopVM(ctx); err != nil {
 		return nil, errors.Wrap(err, "failed to stop VM")
 	}

 	config := wilco.DefaultVMConfig()
 	config.StartProcesses = req.StartProcesses
 	config.TestDBusConfig = req.TestDbusConfig

 	if err := wilco.StartVM(ctx, config); err != nil {
 		return nil, errors.Wrap(err, "failed to start VM")
 	}

 	return &empty.Empty{}, nil
 }

 func (c *WilcoService) GetConfigurationData(ctx context.Context, req *empty.Empty) (*wpb.GetConfigurationDataResponse, error) {
 	if status, err := c.GetStatus(ctx, &empty.Empty{}); err != nil {
 		return nil, errors.Wrap(err, "failed to get status")
 	} else if status.WilcoDtcSupportdPid == 0 {
 		return nil, errors.Wrap(err, "Wilco DTC Support Daemon not running")
 	} else if status.WilcoDtcPid == 0 {
 		return nil, errors.Wrap(err, "Wilco DTC VM not running")
 	}

 	request := dtcpb.GetConfigurationDataRequest{}
 	response := dtcpb.GetConfigurationDataResponse{}

 	if err := wilco.DPSLSendMessage(ctx, "GetConfigurationData", &request, &response); err != nil {
 		return nil, errors.Wrap(err, "unable to get configuration data")
 	}

 	return &wpb.GetConfigurationDataResponse{
 		JsonConfigurationData: response.JsonConfigurationData,
 	}, nil
 }

 func (c *WilcoService) SendMessageToUi(ctx context.Context, req *wpb.SendMessageToUiRequest) (*wpb.SendMessageToUiResponse, error) { // NOLINT
 	if status, err := c.GetStatus(ctx, &empty.Empty{}); err != nil {
 		return nil, errors.Wrap(err, "failed to get status")
 	} else if status.WilcoDtcSupportdPid == 0 {
 		return nil, errors.Wrap(err, "Wilco DTC Support Daemon not running")
 	} else if status.WilcoDtcPid == 0 {
 		return nil, errors.Wrap(err, "Wilco DTC VM not running")
 	}

 	request := dtcpb.SendMessageToUiRequest{
 		JsonMessage: req.JsonMessage,
 	}
 	response := dtcpb.SendMessageToUiResponse{}

 	if err := wilco.DPSLSendMessage(ctx, "SendMessageToUi", &request, &response); err != nil {
 		return nil, errors.Wrap(err, "unable to send message to UI")
 	}

 	return &wpb.SendMessageToUiResponse{
 		ResponseJsonMessage: response.ResponseJsonMessage,
 	}, nil
 }

 func (c *WilcoService) TestPerformWebRequest(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
 	{
 		request := dtcpb.PerformWebRequestParameter{
 			HttpMethod: dtcpb.PerformWebRequestParameter_HTTP_METHOD_GET,
 			Url:        "https://chromium.org",
 		}
 		response := dtcpb.PerformWebRequestResponse{}

 		if err := wilco.DPSLSendMessage(ctx, "PerformWebRequest", &request, &response); err != nil {
 			return nil, errors.Wrap(err, "failed to call PerformWebRequest")
 		}

 		if response.Status == dtcpb.PerformWebRequestResponse_STATUS_INTERNAL_ERROR {
 			return nil, errors.New("received status STATUS_INTERNAL_ERROR")
 		}

 		// TODO(vsavu): Remove logging after test works.
 		if response.Status != dtcpb.PerformWebRequestResponse_STATUS_OK {
 			// Don't fail website isn't reachable from the DUT.
 			testing.ContextLogf(ctx, "Request for chromium.org failed with status %s", response.Status)
 		}
 	}

 	{
 		request := dtcpb.PerformWebRequestParameter{
 			HttpMethod: dtcpb.PerformWebRequestParameter_HTTP_METHOD_GET,
 			Url:        "https://localhost/test",
 		}
 		response := dtcpb.PerformWebRequestResponse{}

 		if err := wilco.DPSLSendMessage(ctx, "PerformWebRequest", &request, &response); err != nil {
 			return nil, errors.Wrap(err, "failed to call PerformWebRequest")
 		}

 		// Requests to localhost are blocked.
 		if response.Status != dtcpb.PerformWebRequestResponse_STATUS_NETWORK_ERROR {
 			return nil, errors.Errorf("invalid status for localhost request; got %s; expect STATUS_NETWORK_ERROR", response.Status)
 		}
 	}

 	// TODO(crbug.com/1064236): add request to test server

 	return &empty.Empty{}, nil
 }

 func (c *WilcoService) ExecuteRoutine(ctx context.Context, req *wpb.ExecuteRoutineRequest) (*wpb.ExecuteRoutineResponse, error) {
 	rrRequest := dtcpb.RunRoutineRequest{}
 	if err := proto.Unmarshal(req.Request, &rrRequest); err != nil {
 		return nil, errors.Wrap(err, "failed to unmarshall request")
 	}

 	rrResponse := dtcpb.RunRoutineResponse{}

 	if err := routines.CallRunRoutine(ctx, rrRequest, &rrResponse); err != nil {
 		return nil, errors.Wrap(err, "unable to run routine")
 	}

 	uuid := rrResponse.Uuid
 	response := dtcpb.GetRoutineUpdateResponse{}

 	if err := routines.WaitUntilRoutineChangesState(ctx, uuid, dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_RUNNING, 30*time.Second); err != nil {
 		return nil, errors.Wrap(err, "routine not finished")
 	}

 	if err := routines.GetRoutineStatus(ctx, uuid, true, &response); err != nil {
 		return nil, errors.Wrap(err, "unable to get routine status")
 	}

 	var status wpb.DiagnosticRoutineStatus
 	switch response.Status {
 	case dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_FAILED:
 		status = wpb.DiagnosticRoutineStatus_ROUTINE_STATUS_FAILED
 	case dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_PASSED:
 		status = wpb.DiagnosticRoutineStatus_ROUTINE_STATUS_PASSED
 	default:
 		testing.ContextLogf(ctx, "Unexpected routine status %s", response.Status)
 		status = wpb.DiagnosticRoutineStatus_ROUTINE_STATUS_ERROR
 	}

 	if err := routines.RemoveRoutine(ctx, uuid); err != nil {
 		return nil, errors.Wrap(err, "unable to remove routine")
 	}

 	return &wpb.ExecuteRoutineResponse{
 		Status: status,
 	}, nil
 }

 func (c *WilcoService) TestRoutineCancellation(ctx context.Context, req *wpb.ExecuteRoutineRequest) (*empty.Empty, error) {
 	rrRequest := dtcpb.RunRoutineRequest{}
 	if err := proto.Unmarshal(req.Request, &rrRequest); err != nil {
 		return nil, errors.Wrap(err, "failed to unmarshall request")
 	}

 	rrResponse := dtcpb.RunRoutineResponse{}
 	if err := routines.CallRunRoutine(ctx, rrRequest, &rrResponse); err != nil {
 		return nil, errors.Wrap(err, "unable to call routine")
 	}

 	uuid := rrResponse.Uuid
 	response := dtcpb.GetRoutineUpdateResponse{}

 	if err := routines.CancelRoutine(ctx, uuid); err != nil {
 		return nil, errors.Wrap(err, "unable to cancel routine")
 	}

 	// Because cancellation is slow, we time how long it takes to change from
 	// STATUS_CANCELLING.
 	ctx, st := timing.Start(ctx, "cancel")
 	err := routines.WaitUntilRoutineChangesState(ctx, uuid, dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_CANCELLING, 30*time.Second)
 	st.End()
 	if err != nil {
 		return nil, errors.Wrap(err, "routine not finished")
 	}

 	if err := routines.GetRoutineStatus(ctx, uuid, true, &response); err != nil {
 		return nil, errors.Wrap(err, "unable to get routine status")
 	}

 	if response.Status != dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_CANCELLED {
 		return nil, errors.Errorf("invalid status; got %s, want ROUTINE_STATUS_CANCELLED", response.Status)
 	}

 	if err := routines.RemoveRoutine(ctx, uuid); err != nil {
 		return nil, errors.Wrap(err, "unable to remove routine")
 	}

 	return &empty.Empty{}, nil
 }

 func (c *WilcoService) TestGetAvailableRoutines(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
 	request := dtcpb.GetAvailableRoutinesRequest{}
 	response := dtcpb.GetAvailableRoutinesResponse{}

 	if err := wilco.DPSLSendMessage(ctx, "GetAvailableRoutines", &request, &response); err != nil {
 		return nil, errors.Wrap(err, "unable to get routines")
 	}

 	contains := func(all []dtcpb.DiagnosticRoutine, expected dtcpb.DiagnosticRoutine) bool {
 		for _, e := range all {
 			if expected == e {
 				return true
 			}
 		}
 		return false
 	}

 	for _, val := range []dtcpb.DiagnosticRoutine{
 		dtcpb.DiagnosticRoutine_ROUTINE_BATTERY,
 		dtcpb.DiagnosticRoutine_ROUTINE_BATTERY_SYSFS,
 		dtcpb.DiagnosticRoutine_ROUTINE_URANDOM,
 		dtcpb.DiagnosticRoutine_ROUTINE_SMARTCTL_CHECK,
 		dtcpb.DiagnosticRoutine_ROUTINE_CPU_CACHE,
 		dtcpb.DiagnosticRoutine_ROUTINE_CPU_STRESS,
 		dtcpb.DiagnosticRoutine_ROUTINE_FLOATING_POINT_ACCURACY,
 		dtcpb.DiagnosticRoutine_ROUTINE_NVME_WEAR_LEVEL,
 		dtcpb.DiagnosticRoutine_ROUTINE_NVME_SHORT_SELF_TEST,
 		dtcpb.DiagnosticRoutine_ROUTINE_NVME_LONG_SELF_TEST,
 	} {
 		if !contains(response.Routines, val) {
 			return nil, errors.Errorf("routine %s missing", val)
 		}
 	}
 	return &empty.Empty{}, nil
 }

 func (c *WilcoService) TestGetStatefulPartitionAvailableCapacity(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
 	const allowedErrorMargin = int32(100) // 100 MiB

 	absDiff := func(a, b int32) int32 {
 		if a > b {
 			return a - b
 		}
 		return b - a
 	}

 	request := dtcpb.GetStatefulPartitionAvailableCapacityRequest{}
 	response := dtcpb.GetStatefulPartitionAvailableCapacityResponse{}

 	if err := wilco.DPSLSendMessage(ctx, "GetStatefulPartitionAvailableCapacity", &request, &response); err != nil {
 		return nil, errors.Wrap(err, "unable to get stateful partition available capacity")
 	}

 	if response.Status != dtcpb.GetStatefulPartitionAvailableCapacityResponse_STATUS_OK {
 		return nil, errors.Errorf("unexpected status %d", response.Status)
 	}

 	var stat syscall.Statfs_t
 	if err := syscall.Statfs("/mnt/stateful_partition", &stat); err != nil {
 		return nil, errors.Wrap(err, "failed to get disk stats for the stateful partition")
 	}

 	realAvailableMb := int32(stat.Bavail * uint64(stat.Bsize) / uint64(1024) / uint64(1024))

 	if response.AvailableCapacityMb%int32(100) > 0 {
 		return nil, errors.Errorf("invalid available capacity (not rounded to 100 MiB): %v", response.AvailableCapacityMb)
 	}

 	if absDiff(response.AvailableCapacityMb, realAvailableMb) > allowedErrorMargin {
 		return nil, errors.Errorf("invalid available capacity: got %v; want %v +- %v", response.AvailableCapacityMb, realAvailableMb, allowedErrorMargin)
 	}

 	return &empty.Empty{}, nil
 }

 func (c *WilcoService) StartDPSLListener(ctx context.Context, req *wpb.StartDPSLListenerRequest) (*empty.Empty, error) {
 	if c.receiver != nil {
 		return nil, errors.New("DPSL listener already running")
 	}

 	ctx, cancel := context.WithCancel(context.Background()) // NOLINT

 	var response *dtcpb.HandleMessageFromUiResponse

 	if len(req.HandleMessageFromUiResponse) > 0 {
 		response = &dtcpb.HandleMessageFromUiResponse{
 			ResponseJsonMessage: req.HandleMessageFromUiResponse,
 		}
 	}

 	rec, err := wilco.NewDPSLMessageReceiver(ctx, wilco.WithHandleMessageFromUiResponse(response))
 	if err != nil {
 		cancel()
 		return nil, errors.Wrap(err, "failed to create dpsl message listener")
 	}

 	c.receiver = rec
 	c.receiverCtxCancel = cancel

 	return &empty.Empty{}, nil
 }

 func (c *WilcoService) StopDPSLListener(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
 	if c.receiver == nil {
 		return nil, errors.New("DPSL listener not running")
 	}

 	c.receiver.Stop(ctx)
 	c.receiver = nil
 	c.receiverCtxCancel()

 	return &empty.Empty{}, nil
 }

 func (c *WilcoService) WaitForHandleConfigurationDataChanged(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
 	if c.receiver == nil {
 		return nil, errors.New("DPSL listener not running")
 	}

 	msg := dtcpb.HandleConfigurationDataChangedRequest{}

 	if err := c.receiver.WaitForMessage(ctx, &msg); err != nil {
 		return nil, errors.Wrap(err, "unable to receive HandleConfigurationDataChanged event")
 	}

 	return &empty.Empty{}, nil
 }

 func (c *WilcoService) WaitForHandleMessageFromUi(ctx context.Context, req *empty.Empty) (*wpb.WaitForHandleMessageFromUiResponse, error) { // NOLINT
 	if c.receiver == nil {
 		return nil, errors.New("DPSL listener not running")
 	}

 	msg := dtcpb.HandleMessageFromUiRequest{}

 	if err := c.receiver.WaitForMessage(ctx, &msg); err != nil {
 		return nil, errors.Wrap(err, "unable to receive HandleMessageFromUi event")
 	}

 	return &wpb.WaitForHandleMessageFromUiResponse{
 		JsonMessage: msg.JsonMessage,
 	}, nil
 }
	// Copyright 2020 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 wilco

	import (
	"context"
	"syscall"
	"time"

	"github.com/golang/protobuf/proto"
	"github.com/golang/protobuf/ptypes/empty"
	"google.golang.org/grpc"

	"chromiumos/tast/errors"
	"chromiumos/tast/local/bundles/cros/wilco/routines"
	"chromiumos/tast/local/wilco"
	wpb "chromiumos/tast/services/cros/wilco"
	"chromiumos/tast/testing"
	"chromiumos/tast/timing"
	dtcpb "chromiumos/wilco_dtc"
	)

	func init() {
	testing.AddService(&testing.Service{
	Register: func(srv grpc.Server, s testing.ServiceState) {
	wpb.RegisterWilcoServiceServer(srv, &WilcoService{s: s})
	},
	})
	}

	// WilcoService implements tast.cros.wilco.WilcoService.
	type WilcoService struct { // NOLINT
	s *testing.ServiceState
	receiver *wilco.DPSLMessageReceiver
	receiverCtxCancel func()
	}

	func (c WilcoService) GetStatus(ctx context.Context, req empty.Empty) (*wpb.GetStatusResponse, error) {
	supportdPID, err := wilco.SupportdPID(ctx)
	if err != nil {
	return nil, errors.Wrap(err, "failed to get status of the Wilco DTC Support Daemon")
	}

	vmPID, err := wilco.VMPID(ctx)
	if err != nil {
	return nil, errors.Wrap(err, "failed to get status of the Wilco DTC VM")
	}

	if supportdPID < 0 {
	return nil, errors.New("PID of Wilco DTC Support Daemon is negative")
	}

	if vmPID < 0 {
	return nil, errors.New("PID of Wilco DTC VM is negative")
	}

	return &wpb.GetStatusResponse{
	WilcoDtcSupportdPid: uint64(supportdPID),
	WilcoDtcPid: uint64(vmPID),
	}, nil
	}

	func (c WilcoService) RestartVM(ctx context.Context, req wpb.RestartVMRequest) (*empty.Empty, error) {
	if err := wilco.StopVM(ctx); err != nil {
	return nil, errors.Wrap(err, "failed to stop VM")
	}

	config := wilco.DefaultVMConfig()
	config.StartProcesses = req.StartProcesses
	config.TestDBusConfig = req.TestDbusConfig

	if err := wilco.StartVM(ctx, config); err != nil {
	return nil, errors.Wrap(err, "failed to start VM")
	}

	return &empty.Empty{}, nil
	}

	func (c WilcoService) GetConfigurationData(ctx context.Context, req empty.Empty) (*wpb.GetConfigurationDataResponse, error) {
	if status, err := c.GetStatus(ctx, &empty.Empty{}); err != nil {
	return nil, errors.Wrap(err, "failed to get status")
	} else if status.WilcoDtcSupportdPid == 0 {
	return nil, errors.Wrap(err, "Wilco DTC Support Daemon not running")
	} else if status.WilcoDtcPid == 0 {
	return nil, errors.Wrap(err, "Wilco DTC VM not running")
	}

	request := dtcpb.GetConfigurationDataRequest{}
	response := dtcpb.GetConfigurationDataResponse{}

	if err := wilco.DPSLSendMessage(ctx, "GetConfigurationData", &request, &response); err != nil {
	return nil, errors.Wrap(err, "unable to get configuration data")
	}

	return &wpb.GetConfigurationDataResponse{
	JsonConfigurationData: response.JsonConfigurationData,
	}, nil
	}

	func (c WilcoService) SendMessageToUi(ctx context.Context, req wpb.SendMessageToUiRequest) (*wpb.SendMessageToUiResponse, error) { // NOLINT
	if status, err := c.GetStatus(ctx, &empty.Empty{}); err != nil {
	return nil, errors.Wrap(err, "failed to get status")
	} else if status.WilcoDtcSupportdPid == 0 {
	return nil, errors.Wrap(err, "Wilco DTC Support Daemon not running")
	} else if status.WilcoDtcPid == 0 {
	return nil, errors.Wrap(err, "Wilco DTC VM not running")
	}

	request := dtcpb.SendMessageToUiRequest{
	JsonMessage: req.JsonMessage,
	}
	response := dtcpb.SendMessageToUiResponse{}

	if err := wilco.DPSLSendMessage(ctx, "SendMessageToUi", &request, &response); err != nil {
	return nil, errors.Wrap(err, "unable to send message to UI")
	}

	return &wpb.SendMessageToUiResponse{
	ResponseJsonMessage: response.ResponseJsonMessage,
	}, nil
	}

	func (c WilcoService) TestPerformWebRequest(ctx context.Context, req empty.Empty) (*empty.Empty, error) {
	{
	request := dtcpb.PerformWebRequestParameter{
	HttpMethod: dtcpb.PerformWebRequestParameter_HTTP_METHOD_GET,
	Url: "https://chromium.org",
	}
	response := dtcpb.PerformWebRequestResponse{}

	if err := wilco.DPSLSendMessage(ctx, "PerformWebRequest", &request, &response); err != nil {
	return nil, errors.Wrap(err, "failed to call PerformWebRequest")
	}

	if response.Status == dtcpb.PerformWebRequestResponse_STATUS_INTERNAL_ERROR {
	return nil, errors.New("received status STATUS_INTERNAL_ERROR")
	}

	// TODO(vsavu): Remove logging after test works.
	if response.Status != dtcpb.PerformWebRequestResponse_STATUS_OK {
	// Don't fail website isn't reachable from the DUT.
	testing.ContextLogf(ctx, "Request for chromium.org failed with status %s", response.Status)
	}
	}

	{
	request := dtcpb.PerformWebRequestParameter{
	HttpMethod: dtcpb.PerformWebRequestParameter_HTTP_METHOD_GET,
	Url: "https://localhost/test",
	}
	response := dtcpb.PerformWebRequestResponse{}

	if err := wilco.DPSLSendMessage(ctx, "PerformWebRequest", &request, &response); err != nil {
	return nil, errors.Wrap(err, "failed to call PerformWebRequest")
	}

	// Requests to localhost are blocked.
	if response.Status != dtcpb.PerformWebRequestResponse_STATUS_NETWORK_ERROR {
	return nil, errors.Errorf("invalid status for localhost request; got %s; expect STATUS_NETWORK_ERROR", response.Status)
	}
	}

	// TODO(crbug.com/1064236): add request to test server

	return &empty.Empty{}, nil
	}

	func (c WilcoService) ExecuteRoutine(ctx context.Context, req wpb.ExecuteRoutineRequest) (*wpb.ExecuteRoutineResponse, error) {
	rrRequest := dtcpb.RunRoutineRequest{}
	if err := proto.Unmarshal(req.Request, &rrRequest); err != nil {
	return nil, errors.Wrap(err, "failed to unmarshall request")
	}

	rrResponse := dtcpb.RunRoutineResponse{}

	if err := routines.CallRunRoutine(ctx, rrRequest, &rrResponse); err != nil {
	return nil, errors.Wrap(err, "unable to run routine")
	}

	uuid := rrResponse.Uuid
	response := dtcpb.GetRoutineUpdateResponse{}

	if err := routines.WaitUntilRoutineChangesState(ctx, uuid, dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_RUNNING, 30*time.Second); err != nil {
	return nil, errors.Wrap(err, "routine not finished")
	}

	if err := routines.GetRoutineStatus(ctx, uuid, true, &response); err != nil {
	return nil, errors.Wrap(err, "unable to get routine status")
	}

	var status wpb.DiagnosticRoutineStatus
	switch response.Status {
	case dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_FAILED:
	status = wpb.DiagnosticRoutineStatus_ROUTINE_STATUS_FAILED
	case dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_PASSED:
	status = wpb.DiagnosticRoutineStatus_ROUTINE_STATUS_PASSED
	default:
	testing.ContextLogf(ctx, "Unexpected routine status %s", response.Status)
	status = wpb.DiagnosticRoutineStatus_ROUTINE_STATUS_ERROR
	}

	if err := routines.RemoveRoutine(ctx, uuid); err != nil {
	return nil, errors.Wrap(err, "unable to remove routine")
	}

	return &wpb.ExecuteRoutineResponse{
	Status: status,
	}, nil
	}

	func (c WilcoService) TestRoutineCancellation(ctx context.Context, req wpb.ExecuteRoutineRequest) (*empty.Empty, error) {
	rrRequest := dtcpb.RunRoutineRequest{}
	if err := proto.Unmarshal(req.Request, &rrRequest); err != nil {
	return nil, errors.Wrap(err, "failed to unmarshall request")
	}

	rrResponse := dtcpb.RunRoutineResponse{}
	if err := routines.CallRunRoutine(ctx, rrRequest, &rrResponse); err != nil {
	return nil, errors.Wrap(err, "unable to call routine")
	}

	uuid := rrResponse.Uuid
	response := dtcpb.GetRoutineUpdateResponse{}

	if err := routines.CancelRoutine(ctx, uuid); err != nil {
	return nil, errors.Wrap(err, "unable to cancel routine")
	}

	// Because cancellation is slow, we time how long it takes to change from
	// STATUS_CANCELLING.
	ctx, st := timing.Start(ctx, "cancel")
	err := routines.WaitUntilRoutineChangesState(ctx, uuid, dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_CANCELLING, 30*time.Second)
	st.End()
	if err != nil {
	return nil, errors.Wrap(err, "routine not finished")
	}

	if err := routines.GetRoutineStatus(ctx, uuid, true, &response); err != nil {
	return nil, errors.Wrap(err, "unable to get routine status")
	}

	if response.Status != dtcpb.DiagnosticRoutineStatus_ROUTINE_STATUS_CANCELLED {
	return nil, errors.Errorf("invalid status; got %s, want ROUTINE_STATUS_CANCELLED", response.Status)
	}

	if err := routines.RemoveRoutine(ctx, uuid); err != nil {
	return nil, errors.Wrap(err, "unable to remove routine")
	}

	return &empty.Empty{}, nil
	}

	func (c WilcoService) TestGetAvailableRoutines(ctx context.Context, req empty.Empty) (*empty.Empty, error) {
	request := dtcpb.GetAvailableRoutinesRequest{}
	response := dtcpb.GetAvailableRoutinesResponse{}

	if err := wilco.DPSLSendMessage(ctx, "GetAvailableRoutines", &request, &response); err != nil {
	return nil, errors.Wrap(err, "unable to get routines")
	}

	contains := func(all []dtcpb.DiagnosticRoutine, expected dtcpb.DiagnosticRoutine) bool {
	for _, e := range all {
	if expected == e {
	return true
	}
	}
	return false
	}

	for _, val := range []dtcpb.DiagnosticRoutine{
	dtcpb.DiagnosticRoutine_ROUTINE_BATTERY,
	dtcpb.DiagnosticRoutine_ROUTINE_BATTERY_SYSFS,
	dtcpb.DiagnosticRoutine_ROUTINE_URANDOM,
	dtcpb.DiagnosticRoutine_ROUTINE_SMARTCTL_CHECK,
	dtcpb.DiagnosticRoutine_ROUTINE_CPU_CACHE,
	dtcpb.DiagnosticRoutine_ROUTINE_CPU_STRESS,
	dtcpb.DiagnosticRoutine_ROUTINE_FLOATING_POINT_ACCURACY,
	dtcpb.DiagnosticRoutine_ROUTINE_NVME_WEAR_LEVEL,
	dtcpb.DiagnosticRoutine_ROUTINE_NVME_SHORT_SELF_TEST,
	dtcpb.DiagnosticRoutine_ROUTINE_NVME_LONG_SELF_TEST,
	} {
	if !contains(response.Routines, val) {
	return nil, errors.Errorf("routine %s missing", val)
	}
	}
	return &empty.Empty{}, nil
	}

	func (c WilcoService) TestGetStatefulPartitionAvailableCapacity(ctx context.Context, req empty.Empty) (*empty.Empty, error) {
	const allowedErrorMargin = int32(100) // 100 MiB

	absDiff := func(a, b int32) int32 {
	if a > b {
	return a - b
	}
	return b - a
	}

	request := dtcpb.GetStatefulPartitionAvailableCapacityRequest{}
	response := dtcpb.GetStatefulPartitionAvailableCapacityResponse{}

	if err := wilco.DPSLSendMessage(ctx, "GetStatefulPartitionAvailableCapacity", &request, &response); err != nil {
	return nil, errors.Wrap(err, "unable to get stateful partition available capacity")
	}

	if response.Status != dtcpb.GetStatefulPartitionAvailableCapacityResponse_STATUS_OK {
	return nil, errors.Errorf("unexpected status %d", response.Status)
	}

	var stat syscall.Statfs_t
	if err := syscall.Statfs("/mnt/stateful_partition", &stat); err != nil {
	return nil, errors.Wrap(err, "failed to get disk stats for the stateful partition")
	}

	realAvailableMb := int32(stat.Bavail * uint64(stat.Bsize) / uint64(1024) / uint64(1024))

	if response.AvailableCapacityMb%int32(100) > 0 {
	return nil, errors.Errorf("invalid available capacity (not rounded to 100 MiB): %v", response.AvailableCapacityMb)
	}

	if absDiff(response.AvailableCapacityMb, realAvailableMb) > allowedErrorMargin {
	return nil, errors.Errorf("invalid available capacity: got %v; want %v +- %v", response.AvailableCapacityMb, realAvailableMb, allowedErrorMargin)
	}

	return &empty.Empty{}, nil
	}

	func (c WilcoService) StartDPSLListener(ctx context.Context, req wpb.StartDPSLListenerRequest) (*empty.Empty, error) {
	if c.receiver != nil {
	return nil, errors.New("DPSL listener already running")
	}

	ctx, cancel := context.WithCancel(context.Background()) // NOLINT

	var response *dtcpb.HandleMessageFromUiResponse

	if len(req.HandleMessageFromUiResponse) > 0 {
	response = &dtcpb.HandleMessageFromUiResponse{
	ResponseJsonMessage: req.HandleMessageFromUiResponse,
	}
	}

	rec, err := wilco.NewDPSLMessageReceiver(ctx, wilco.WithHandleMessageFromUiResponse(response))
	if err != nil {
	cancel()
	return nil, errors.Wrap(err, "failed to create dpsl message listener")
	}

	c.receiver = rec
	c.receiverCtxCancel = cancel

	return &empty.Empty{}, nil
	}

	func (c WilcoService) StopDPSLListener(ctx context.Context, req empty.Empty) (*empty.Empty, error) {
	if c.receiver == nil {
	return nil, errors.New("DPSL listener not running")
	}

	c.receiver.Stop(ctx)
	c.receiver = nil
	c.receiverCtxCancel()

	return &empty.Empty{}, nil
	}

	func (c WilcoService) WaitForHandleConfigurationDataChanged(ctx context.Context, req empty.Empty) (*empty.Empty, error) {
	if c.receiver == nil {
	return nil, errors.New("DPSL listener not running")
	}

	msg := dtcpb.HandleConfigurationDataChangedRequest{}

	if err := c.receiver.WaitForMessage(ctx, &msg); err != nil {
	return nil, errors.Wrap(err, "unable to receive HandleConfigurationDataChanged event")
	}

	return &empty.Empty{}, nil
	}

	func (c WilcoService) WaitForHandleMessageFromUi(ctx context.Context, req empty.Empty) (*wpb.WaitForHandleMessageFromUiResponse, error) { // NOLINT
	if c.receiver == nil {
	return nil, errors.New("DPSL listener not running")
	}

	msg := dtcpb.HandleMessageFromUiRequest{}

	if err := c.receiver.WaitForMessage(ctx, &msg); err != nil {
	return nil, errors.Wrap(err, "unable to receive HandleMessageFromUi event")
	}

	return &wpb.WaitForHandleMessageFromUiResponse{
	JsonMessage: msg.JsonMessage,
	}, nil
	}