170 lines
6.7 KiB
Python
170 lines
6.7 KiB
Python
#
|
|
# Copyright (C) 2017 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
|
|
import logging
|
|
import socket
|
|
import threading
|
|
|
|
import httplib2
|
|
from googleapiclient import errors
|
|
|
|
from host_controller.tfc import command_attempt
|
|
from host_controller.tradefed import remote_operation
|
|
|
|
|
|
class InvocationThread(threading.Thread):
|
|
"""The thread that remotely executes a command task.
|
|
|
|
Attributes:
|
|
_remote_client: The RemoteClient which executes the command.
|
|
_tfc_client: The TfcClient to which the command events are sent.
|
|
_attempt: The CommandAttempt whose events are sent to TFC.
|
|
_command: A list of strings, the command and arguments.
|
|
device_serials: A list of strings, the serial numbers of the devices
|
|
which need to be allocated to the task.
|
|
_allocated_serials: A list of strings, the serial numbers of the devices
|
|
which are successfully allocated.
|
|
_tfc_heartbeat_interval: The interval of TestRunInProgress events in
|
|
seconds.
|
|
"""
|
|
|
|
def __init__(self,
|
|
remote_client,
|
|
tfc_client,
|
|
attempt,
|
|
command,
|
|
device_serials,
|
|
tfc_heartbeat_interval=5 * 60):
|
|
"""Initializes the attributes."""
|
|
super(InvocationThread, self).__init__()
|
|
self._remote_client = remote_client
|
|
self._tfc_client = tfc_client
|
|
self._attempt = attempt
|
|
self._command = command
|
|
self.device_serials = device_serials
|
|
self._allocated_serials = None
|
|
# The value in Java implementation is 5 minutes.
|
|
self._tfc_heartbeat_interval = tfc_heartbeat_interval
|
|
|
|
def _AllocateDevices(self):
|
|
"""Allocates all of device_serial."""
|
|
for serial in self.device_serials:
|
|
self._remote_client.SendOperation(
|
|
remote_operation.AllocateDevice(serial))
|
|
self._allocated_serials.append(serial)
|
|
|
|
def _StartInvocation(self):
|
|
"""Starts executing command and sends the event to TFC."""
|
|
self._remote_client.SendOperation(
|
|
remote_operation.ExecuteCommand(self.device_serials[0],
|
|
*self._command))
|
|
event = self._attempt.CreateCommandEvent(
|
|
command_attempt.EventType.INVOCATION_STARTED)
|
|
self._tfc_client.SubmitCommandEvents([event])
|
|
|
|
def _WaitForCommandResult(self):
|
|
"""Waits for command result and keeps sending heartbeat to TFC
|
|
|
|
Returns:
|
|
A JSON object returned from TradeFed remote manager.
|
|
"""
|
|
while True:
|
|
result = self._remote_client.WaitForCommandResult(
|
|
self.device_serials[0], self._tfc_heartbeat_interval)
|
|
if result:
|
|
return result
|
|
event = self._attempt.CreateCommandEvent(
|
|
command_attempt.EventType.TEST_RUN_IN_PROGRESS)
|
|
self._tfc_client.SubmitCommandEvents([event])
|
|
|
|
def _CompleteInvocation(self, result):
|
|
"""Sends InvocationCompleted event according to the result.
|
|
|
|
Args:
|
|
result: A JSON object returned from TradeFed remote manager.
|
|
"""
|
|
if result["status"] == "INVOCATION_SUCCESS":
|
|
event = self._attempt.CreateInvocationCompletedEvent(
|
|
str(result), 1, 0)
|
|
else:
|
|
event = self._attempt.CreateInvocationCompletedEvent(
|
|
str(result), 1, 1, error=str(result))
|
|
self._tfc_client.SubmitCommandEvents([event])
|
|
|
|
def _FreeAllocatedDevices(self):
|
|
"""Frees allocated devices and tolerates RemoteOperationException."""
|
|
for serial in self._allocated_serials:
|
|
try:
|
|
self._remote_client.SendOperation(
|
|
remote_operation.FreeDevice(serial))
|
|
except remote_operation.RemoteOperationException as e:
|
|
logging.exception(e)
|
|
except socket.error as e:
|
|
logging.exception(e)
|
|
break
|
|
self._allocated_serials = []
|
|
|
|
def _SubmitErrorEvent(self, event_type, error_msg):
|
|
"""Submits an error event and tolerates http exceptions.
|
|
|
|
Args:
|
|
event_type: A string, the type of the command event.
|
|
error_msg: A string, the error message.
|
|
"""
|
|
try:
|
|
self._tfc_client.SubmitCommandEvents(
|
|
[self._attempt.CreateCommandEvent(event_type, error_msg)])
|
|
except (httplib2.HttpLib2Error, errors.HttpError) as e:
|
|
logging.exception(e)
|
|
|
|
# @Override
|
|
def run(self):
|
|
"""Executes a command task with exception handling."""
|
|
self._allocated_serials = []
|
|
last_error = None
|
|
error_event = command_attempt.EventType.ALLOCATION_FAILED
|
|
try:
|
|
self._AllocateDevices()
|
|
error_event = command_attempt.EventType.EXECUTE_FAILED
|
|
self._StartInvocation()
|
|
result = self._WaitForCommandResult()
|
|
self._CompleteInvocation(result)
|
|
error_event = None
|
|
except errors.HttpError as e:
|
|
logging.exception(e)
|
|
last_error = e
|
|
except remote_operation.RemoteOperationException as e:
|
|
logging.exception(e)
|
|
last_error = e
|
|
# ConfigurationException on TradeFed remote manager.
|
|
if str(e).startswith("Config error: "):
|
|
error_event = command_attempt.EventType.CONFIGURATION_ERROR
|
|
except httplib2.HttpLib2Error as e:
|
|
logging.exception("Cannot communicate with TradeFed cluster: %s\n"
|
|
"Skip submitting event %s.", e, error_event)
|
|
last_error = e
|
|
error_event = None
|
|
except socket.error as e:
|
|
logging.exception("Cannot communicate with TradeFed remote "
|
|
"manager: %s\nSkip freeing devices %s.",
|
|
e, self._allocated_serials)
|
|
last_error = e
|
|
self._allocated_serials = []
|
|
finally:
|
|
if error_event:
|
|
self._SubmitErrorEvent(error_event, str(last_error))
|
|
self._FreeAllocatedDevices()
|