mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
54d781abf7
It turns out that relying on the user to check return codes for every command was non-intuitive and resulted in many hard to trace bugs. Now most functinos just return "None", and raise a DMError when there's an exception. The exception to this are functions like dirExists, which now return booleans, and throw exceptions on error. This is a fairly major refactor, and also involved the following internal changes: * Removed FileError and AgentError exceptions, replaced with DMError (having to manage three different types of exceptions was confusing, all the more so when we're raising them) * Docstrings updated to remove references to return values where no longer relevant * pushFile no longer will create a directory to accomodate the file if it doesn't exist (this makes it consistent with devicemanagerADB) * dmSUT we validate the file, but assume that we get something back from the agent, instead of falling back to manual validation in the case that we didn't * isDir and dirExists had the same intention, but different implementations for dmSUT. Replaced the dmSUT impl of getDirectory with that of isDir's (which was much simpler). Removed isDir from devicemanager.py, since it wasn't used externally * killProcess modified to check for process existence before running (since the actual internal kill command will throw an exception if the process doesn't exist) In addition to all this, more unit tests have been added to test these changes for devicemanagerSUT.
207 lines
7.5 KiB
Python
207 lines
7.5 KiB
Python
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
import time
|
|
import os
|
|
import automationutils
|
|
import tempfile
|
|
import shutil
|
|
import subprocess
|
|
|
|
from automation import Automation
|
|
from devicemanager import NetworkTools, DMError
|
|
|
|
class RemoteAutomation(Automation):
|
|
_devicemanager = None
|
|
|
|
def __init__(self, deviceManager, appName = '', remoteLog = None):
|
|
self._devicemanager = deviceManager
|
|
self._appName = appName
|
|
self._remoteProfile = None
|
|
self._remoteLog = remoteLog
|
|
|
|
# Default our product to fennec
|
|
self._product = "fennec"
|
|
Automation.__init__(self)
|
|
|
|
def setDeviceManager(self, deviceManager):
|
|
self._devicemanager = deviceManager
|
|
|
|
def setAppName(self, appName):
|
|
self._appName = appName
|
|
|
|
def setRemoteProfile(self, remoteProfile):
|
|
self._remoteProfile = remoteProfile
|
|
|
|
def setProduct(self, product):
|
|
self._product = product
|
|
|
|
def setRemoteLog(self, logfile):
|
|
self._remoteLog = logfile
|
|
|
|
# Set up what we need for the remote environment
|
|
def environment(self, env = None, xrePath = None, crashreporter = True):
|
|
# Because we are running remote, we don't want to mimic the local env
|
|
# so no copying of os.environ
|
|
if env is None:
|
|
env = {}
|
|
|
|
# Except for the mochitest results table hiding option, which isn't
|
|
# passed to runtestsremote.py as an actual option, but through the
|
|
# MOZ_CRASHREPORTER_DISABLE environment variable.
|
|
if 'MOZ_HIDE_RESULTS_TABLE' in os.environ:
|
|
env['MOZ_HIDE_RESULTS_TABLE'] = os.environ['MOZ_HIDE_RESULTS_TABLE']
|
|
|
|
if crashreporter:
|
|
env['MOZ_CRASHREPORTER_NO_REPORT'] = '1'
|
|
env['MOZ_CRASHREPORTER'] = '1'
|
|
else:
|
|
env['MOZ_CRASHREPORTER_DISABLE'] = '1'
|
|
|
|
return env
|
|
|
|
def waitForFinish(self, proc, utilityPath, timeout, maxTime, startTime, debuggerInfo, symbolsDir):
|
|
# maxTime is used to override the default timeout, we should honor that
|
|
status = proc.wait(timeout = maxTime)
|
|
|
|
print proc.stdout
|
|
|
|
if (status == 1 and self._devicemanager.processExist(proc.procName)):
|
|
# Then we timed out, make sure Fennec is dead
|
|
proc.kill()
|
|
|
|
return status
|
|
|
|
def checkForCrashes(self, directory, symbolsPath):
|
|
dumpDir = tempfile.mkdtemp()
|
|
self._devicemanager.getDirectory(self._remoteProfile + '/minidumps/', dumpDir)
|
|
automationutils.checkForCrashes(dumpDir, symbolsPath, self.lastTestSeen)
|
|
try:
|
|
shutil.rmtree(dumpDir)
|
|
except:
|
|
print "WARNING: unable to remove directory: %s" % (dumpDir)
|
|
|
|
def buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs):
|
|
# If remote profile is specified, use that instead
|
|
if (self._remoteProfile):
|
|
profileDir = self._remoteProfile
|
|
|
|
# Hack for robocop, if app & testURL == None and extraArgs contains the rest of the stuff, lets
|
|
# assume extraArgs is all we need
|
|
if app == "am" and extraArgs[0] == "instrument":
|
|
return app, extraArgs
|
|
|
|
cmd, args = Automation.buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs)
|
|
# Remove -foreground if it exists, if it doesn't this just returns
|
|
try:
|
|
args.remove('-foreground')
|
|
except:
|
|
pass
|
|
#TODO: figure out which platform require NO_EM_RESTART
|
|
# return app, ['--environ:NO_EM_RESTART=1'] + args
|
|
return app, args
|
|
|
|
def getLanIp(self):
|
|
nettools = NetworkTools()
|
|
return nettools.getLanIp()
|
|
|
|
def Process(self, cmd, stdout = None, stderr = None, env = None, cwd = None):
|
|
if stdout == None or stdout == -1 or stdout == subprocess.PIPE:
|
|
stdout = self._remoteLog
|
|
|
|
return self.RProcess(self._devicemanager, cmd, stdout, stderr, env, cwd)
|
|
|
|
# be careful here as this inner class doesn't have access to outer class members
|
|
class RProcess(object):
|
|
# device manager process
|
|
dm = None
|
|
def __init__(self, dm, cmd, stdout = None, stderr = None, env = None, cwd = None):
|
|
self.dm = dm
|
|
self.stdoutlen = 0
|
|
self.proc = dm.launchProcess(cmd, stdout, cwd, env, True)
|
|
if (self.proc is None):
|
|
if cmd[0] == 'am':
|
|
self.proc = stdout
|
|
else:
|
|
raise Exception("unable to launch process")
|
|
exepath = cmd[0]
|
|
name = exepath.split('/')[-1]
|
|
self.procName = name
|
|
# Hack for Robocop: Derive the actual process name from the command line.
|
|
# We expect something like:
|
|
# ['am', 'instrument', '-w', '-e', 'class', 'org.mozilla.fennec.tests.testBookmark', 'org.mozilla.roboexample.test/android.test.InstrumentationTestRunner']
|
|
# and want to derive 'org.mozilla.fennec'.
|
|
if cmd[0] == 'am' and cmd[1] == "instrument":
|
|
try:
|
|
i = cmd.index("class")
|
|
except ValueError:
|
|
# no "class" argument -- maybe this isn't robocop?
|
|
i = -1
|
|
if (i > 0):
|
|
classname = cmd[i+1]
|
|
parts = classname.split('.')
|
|
try:
|
|
i = parts.index("tests")
|
|
except ValueError:
|
|
# no "tests" component -- maybe this isn't robocop?
|
|
i = -1
|
|
if (i > 0):
|
|
self.procName = '.'.join(parts[0:i])
|
|
print "Robocop derived process name: "+self.procName
|
|
|
|
# Setting timeout at 1 hour since on a remote device this takes much longer
|
|
self.timeout = 3600
|
|
# The benefit of the following sleep is unclear; it was formerly 15 seconds
|
|
time.sleep(1)
|
|
|
|
@property
|
|
def pid(self):
|
|
pid = self.dm.processExist(self.procName)
|
|
# HACK: we should probably be more sophisticated about monitoring
|
|
# running processes for the remote case, but for now we'll assume
|
|
# that this method can be called when nothing exists and it is not
|
|
# an error
|
|
if pid is None:
|
|
return 0
|
|
return pid
|
|
|
|
@property
|
|
def stdout(self):
|
|
if self.dm.fileExists(self.proc):
|
|
try:
|
|
t = self.dm.pullFile(self.proc)
|
|
except DMError:
|
|
# we currently don't retry properly in the pullFile
|
|
# function in dmSUT, so an error here is not necessarily
|
|
# the end of the world
|
|
return ''
|
|
tlen = len(t)
|
|
retVal = t[self.stdoutlen:]
|
|
self.stdoutlen = tlen
|
|
return retVal.strip('\n').strip()
|
|
else:
|
|
return ''
|
|
|
|
def wait(self, timeout = None):
|
|
timer = 0
|
|
interval = 5
|
|
|
|
if timeout == None:
|
|
timeout = self.timeout
|
|
|
|
while (self.dm.processExist(self.procName)):
|
|
t = self.stdout
|
|
if t != '': print t
|
|
time.sleep(interval)
|
|
timer += interval
|
|
if (timer > timeout):
|
|
break
|
|
|
|
if (timer >= timeout):
|
|
return 1
|
|
return 0
|
|
|
|
def kill(self):
|
|
self.dm.killProcess(self.procName)
|