| # 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 select |
| import socket |
| import SocketServer |
| import time |
| import os |
| import re |
| import posixpath |
| import subprocess |
| from threading import Thread |
| import StringIO |
| from devicemanager import DeviceManager, FileError, DMError, NetworkTools, _pop_last_line |
| import errno |
| from distutils.version import StrictVersion |
| |
| |
| class AgentError(Exception): |
| "SUTAgent-specific exception." |
| |
| def __init__(self, msg='', fatal=False): |
| self.msg = msg |
| self.fatal = fatal |
| |
| def __str__(self): |
| return self.msg |
| |
| |
| class DeviceManagerSUT(DeviceManager): |
| debug = 2 |
| tempRoot = os.getcwd() |
| base_prompt = '$>' |
| base_prompt_re = '\$\>' |
| prompt_sep = '\x00' |
| prompt_regex = '.*(' + base_prompt_re + prompt_sep + ')' |
| agentErrorRE = re.compile('^##AGENT-WARNING##\ ?(.*)') |
| default_timeout = 300 |
| |
| # TODO: member variable to indicate error conditions. |
| # This should be set to a standard error from the errno module. |
| # So, for example, when an error occurs because of a missing file/directory, |
| # before returning, the function would do something like 'self.error = errno.ENOENT'. |
| # The error would be set where appropriate--so sendCMD() could set socket errors, |
| # pushFile() and other file-related commands could set filesystem errors, |
| # etc. |
| |
| def __init__(self, host, port=20701, retrylimit=5, deviceRoot=None): |
| self.host = host |
| self.port = port |
| self.retrylimit = retrylimit |
| self._sock = None |
| self.deviceRoot = deviceRoot |
| if self.getDeviceRoot() == None: |
| raise BaseException("Failed to connect to SUT Agent and retrieve the device root.") |
| try: |
| verstring = self._runCmds([{'cmd': 'ver'}]) |
| self.agentVersion = re.sub( |
| 'SUTAgentAndroid Version ', '', verstring) |
| except AgentError, err: |
| raise BaseException("Failed to get SUTAgent version") |
| |
| def _cmdNeedsResponse(self, cmd): |
| """ Not all commands need a response from the agent: |
| * rebt obviously doesn't get a response |
| * uninstall performs a reboot to ensure starting in a clean state and |
| so also doesn't look for a response |
| """ |
| noResponseCmds = [re.compile('^rebt'), |
| re.compile('^uninst .*$'), |
| re.compile('^pull .*$')] |
| |
| for c in noResponseCmds: |
| if (c.match(cmd)): |
| return False |
| |
| # If the command is not in our list, then it gets a response |
| return True |
| |
| def _stripPrompt(self, data): |
| """ |
| internal function |
| take a data blob and strip instances of the prompt '$>\x00' |
| """ |
| promptre = re.compile(self.prompt_regex + '.*') |
| retVal = [] |
| lines = data.split('\n') |
| for line in lines: |
| foundPrompt = False |
| try: |
| while (promptre.match(line)): |
| foundPrompt = True |
| pieces = line.split(self.prompt_sep) |
| index = pieces.index('$>') |
| pieces.pop(index) |
| line = self.prompt_sep.join(pieces) |
| except(ValueError): |
| pass |
| |
| # we don't want to append lines that are blank after stripping the |
| # prompt (those are basically "prompts") |
| if not foundPrompt or line: |
| retVal.append(line) |
| |
| return '\n'.join(retVal) |
| |
| def _shouldCmdCloseSocket(self, cmd): |
| """ |
| Some commands need to close the socket after they are sent: |
| * rebt |
| * uninst |
| * quit |
| """ |
| socketClosingCmds = [re.compile('^quit.*'), |
| re.compile('^rebt.*'), |
| re.compile('^uninst .*$')] |
| |
| for c in socketClosingCmds: |
| if (c.match(cmd)): |
| return True |
| return False |
| |
| def _sendCmds(self, cmdlist, outputfile, timeout=None): |
| """ |
| Wrapper for _doCmds that loops up to self.retrylimit iterations |
| """ |
| # this allows us to move the retry logic outside of the _doCmds() to make it |
| # easier for debugging in the future. |
| # note that since cmdlist is a list of commands, they will all be retried if |
| # one fails. this is necessary in particular for pushFile(), where we don't want |
| # to accidentally send extra data if a failure occurs during data |
| # transmission. |
| |
| retries = 0 |
| while retries < self.retrylimit: |
| try: |
| self._doCmds(cmdlist, outputfile, timeout) |
| return |
| except AgentError, err: |
| # re-raise error if it's fatal (i.e. the device got the command but |
| # couldn't execute it). retry otherwise |
| if err.fatal: |
| raise err |
| if self.debug >= 4: |
| print err |
| retries += 1 |
| # if we lost the connection or failed to establish one, wait a |
| # bit |
| if retries < self.retrylimit and not self._sock: |
| sleep_time = 5 * retries |
| print 'Could not connect; sleeping for %d seconds.' % sleep_time |
| time.sleep(sleep_time) |
| |
| raise AgentError("Remote Device Error: unable to connect to %s after %s attempts" % (self.host, self.retrylimit)) |
| |
| def _runCmds(self, cmdlist, timeout=None): |
| """ |
| Similar to _sendCmds, but just returns any output as a string instead of |
| writing to a file |
| """ |
| outputfile = StringIO.StringIO() |
| self._sendCmds(cmdlist, outputfile, timeout) |
| outputfile.seek(0) |
| return outputfile.read() |
| |
| def _doCmds(self, cmdlist, outputfile, timeout): |
| promptre = re.compile(self.prompt_regex + '$') |
| shouldCloseSocket = False |
| |
| if not timeout: |
| # We are asserting that all commands will complete in this time |
| # unless otherwise specified |
| timeout = self.default_timeout |
| |
| if not self._sock: |
| try: |
| if self.debug >= 1: |
| print "reconnecting socket" |
| self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
| except socket.error, msg: |
| self._sock = None |
| raise AgentError( |
| "Automation Error: unable to create socket: " + str(msg)) |
| |
| try: |
| self._sock.connect((self.host, int(self.port))) |
| if select.select([self._sock], [], [], timeout)[0]: |
| self._sock.recv(1024) |
| else: |
| raise AgentError("Remote Device Error: Timeout in connecting", fatal=True) |
| return False |
| except socket.error, msg: |
| self._sock.close() |
| self._sock = None |
| raise AgentError("Remote Device Error: unable to connect socket: " + str(msg)) |
| |
| for cmd in cmdlist: |
| cmdline = '%s\r\n' % cmd['cmd'] |
| |
| try: |
| sent = self._sock.send(cmdline) |
| if sent != len(cmdline): |
| raise AgentError("ERROR: our cmd was %s bytes and we " |
| "only sent %s" % (len(cmdline), sent)) |
| if cmd.get('data'): |
| sent = self._sock.send(cmd['data']) |
| if sent != len(cmd['data']): |
| raise AgentError("ERROR: we had %s bytes of data to send, but " |
| "only sent %s" % (len(cmd['data']), sent)) |
| |
| if self.debug >= 4: |
| print "sent cmd: " + str(cmd['cmd']) |
| except socket.error, msg: |
| self._sock.close() |
| self._sock = None |
| if self.debug >= 1: |
| print "Remote Device Error: Error sending data to socket. cmd=" + str(cmd['cmd']) + "; err=" + str(msg) |
| return False |
| |
| # Check if the command should close the socket |
| shouldCloseSocket = self._shouldCmdCloseSocket(cmd['cmd']) |
| |
| # Handle responses from commands |
| if self._cmdNeedsResponse(cmd['cmd']): |
| foundPrompt = False |
| data = "" |
| timer = 0 |
| select_timeout = 1 |
| commandFailed = False |
| |
| while not foundPrompt: |
| socketClosed = False |
| errStr = '' |
| temp = '' |
| if self.debug >= 4: |
| print "recv'ing..." |
| |
| # Get our response |
| try: |
| # Wait up to a second for socket to become ready for |
| # reading... |
| if select.select([self._sock], [], [], select_timeout)[0]: |
| temp = self._sock.recv(1024) |
| if self.debug >= 4: |
| print "response: " + str(temp) |
| timer = 0 |
| if not temp: |
| socketClosed = True |
| errStr = 'connection closed' |
| timer += select_timeout |
| if timer > timeout: |
| raise AgentError("Automation Error: Timeout in command %s" % cmd['cmd'], fatal=True) |
| except socket.error, err: |
| socketClosed = True |
| errStr = str(err) |
| # This error shows up with we have our tegra rebooted. |
| if err[0] == errno.ECONNRESET: |
| errStr += ' - possible reboot' |
| |
| if socketClosed: |
| self._sock.close() |
| self._sock = None |
| raise AgentError("Automation Error: Error receiving data from socket. cmd=%s; err=%s" % (cmd, errStr)) |
| |
| data += temp |
| |
| # If something goes wrong in the agent it will send back a string that |
| # starts with '##AGENT-WARNING##' |
| if not commandFailed: |
| errorMatch = self.agentErrorRE.match(data) |
| if errorMatch: |
| # We still need to consume the prompt, so raise an error after |
| # draining the rest of the buffer. |
| commandFailed = True |
| |
| for line in data.splitlines(): |
| if promptre.match(line): |
| foundPrompt = True |
| data = self._stripPrompt(data) |
| break |
| |
| # periodically flush data to output file to make sure it doesn't get |
| # too big/unwieldly |
| if len(data) > 1024: |
| outputfile.write(data[0:1024]) |
| data = data[1024:] |
| |
| if commandFailed: |
| raise AgentError("Automation Error: Agent Error processing command '%s'; err='%s'" % |
| (cmd['cmd'], errorMatch.group(1)), fatal=True) |
| |
| # Write any remaining data to outputfile |
| outputfile.write(data) |
| |
| if shouldCloseSocket: |
| try: |
| self._sock.close() |
| self._sock = None |
| except: |
| self._sock = None |
| raise AgentError("Automation Error: Error closing socket") |
| |
| def shell(self, cmd, outputfile, env=None, cwd=None, timeout=None, root=False): |
| """ |
| Executes shell command on device. |
| |
| cmd - Command string to execute |
| outputfile - File to store output |
| env - Environment to pass to exec command |
| cwd - Directory to execute command from |
| timeout - specified in seconds, defaults to 'default_timeout' |
| root - Specifies whether command requires root privileges |
| |
| returns: |
| success: Return code from command |
| failure: None |
| """ |
| |
| cmdline = self._escapedCommandLine(cmd) |
| if env: |
| cmdline = '%s %s' % (self._formatEnvString(env), cmdline) |
| |
| haveExecSu = ( |
| StrictVersion(self.agentVersion) >= StrictVersion('1.13')) |
| |
| # Depending on agent version we send one of the following commands here: |
| # * exec (run as normal user) |
| # * execsu (run as privileged user) |
| # * execcwd (run as normal user from specified directory) |
| # * execcwdsu (run as privileged user from specified directory) |
| |
| cmd = "exec" |
| if cwd: |
| cmd += "cwd" |
| if root and haveExecSu: |
| cmd += "su" |
| |
| try: |
| if cwd: |
| self._sendCmds([{'cmd': '%s %s %s' % (cmd, |
| cwd, cmdline)}], outputfile, timeout) |
| else: |
| if (not root) or haveExecSu: |
| self._sendCmds([{'cmd': '%s %s' % ( |
| cmd, cmdline)}], outputfile, timeout) |
| else: |
| # need to manually inject su -c for backwards compatibility (this may |
| # not work on ICS or above!!) |
| # (FIXME: this backwards compatibility code is really ugly and should |
| # be deprecated at some point in the future) |
| self._sendCmds( |
| [{'cmd': '%s su -c "%s"' % |
| (cmd, cmdline)}], outputfile, |
| timeout) |
| except AgentError: |
| return None |
| |
| # dig through the output to get the return code |
| lastline = _pop_last_line(outputfile) |
| if lastline: |
| m = re.search('return code \[([0-9]+)\]', lastline) |
| if m: |
| return int(m.group(1)) |
| |
| # woops, we couldn't find an end of line/return value |
| return None |
| |
| def pushFile(self, localname, destname): |
| """ |
| Copies localname from the host to destname on the device |
| |
| returns: |
| success: True |
| failure: False |
| """ |
| if (os.name == "nt"): |
| destname = destname.replace('\\', '/') |
| |
| if (self.debug >= 3): |
| print "in push file with: " + localname + ", and: " + destname |
| if (self.dirExists(destname)): |
| if (not destname.endswith('/')): |
| destname = destname + '/' |
| destname = destname + os.path.basename(localname) |
| if (self.validateFile(destname, localname) == True): |
| if (self.debug >= 3): |
| print "files are validated" |
| return True |
| |
| self.mkDirs(destname) |
| |
| if (self.debug >= 3): |
| print "sending: push " + destname |
| |
| filesize = os.path.getsize(localname) |
| f = open(localname, 'rb') |
| data = f.read() |
| f.close() |
| |
| try: |
| retVal = self._runCmds( |
| [{'cmd': 'push ' + destname + ' ' + str(filesize), |
| 'data': data}]) |
| except AgentError, e: |
| print "Automation Error: error pushing file: %s" % e.msg |
| return False |
| |
| if (self.debug >= 3): |
| print "push returned: " + str(retVal) |
| |
| validated = False |
| if (retVal): |
| retline = retVal.strip() |
| if (retline == None): |
| # Then we failed to get back a hash from agent, try manual |
| # validation |
| validated = self.validateFile(destname, localname) |
| else: |
| # Then we obtained a hash from push |
| localHash = self._getLocalHash(localname) |
| if (str(localHash) == str(retline)): |
| validated = True |
| else: |
| # We got nothing back from sendCMD, try manual validation |
| validated = self.validateFile(destname, localname) |
| |
| if (validated): |
| if (self.debug >= 3): |
| print "Push File Validated!" |
| return True |
| else: |
| if (self.debug >= 2): |
| print "Automation Error: Push File Failed to Validate!" |
| return False |
| |
| def mkDir(self, name): |
| """ |
| Creates a single directory on the device file system |
| |
| returns: |
| success: directory name |
| failure: None |
| """ |
| if (self.dirExists(name)): |
| return name |
| else: |
| try: |
| retVal = self._runCmds([{'cmd': 'mkdr ' + name}]) |
| except AgentError: |
| retVal = None |
| return retVal |
| |
| def pushDir(self, localDir, remoteDir): |
| """ |
| Push localDir from host to remoteDir on the device |
| |
| returns: |
| success: remoteDir |
| failure: None |
| """ |
| if (self.debug >= 2): |
| print "pushing directory: %s to %s" % (localDir, remoteDir) |
| for root, dirs, files in os.walk(localDir, followlinks=True): |
| parts = root.split(localDir) |
| for f in files: |
| remoteRoot = remoteDir + '/' + parts[1] |
| if (remoteRoot.endswith('/')): |
| remoteName = remoteRoot + f |
| else: |
| remoteName = remoteRoot + '/' + f |
| if (parts[1] == ""): |
| remoteRoot = remoteDir |
| if (self.pushFile(os.path.join(root, f), remoteName) == False): |
| # retry once |
| self.removeFile(remoteName) |
| if (self.pushFile(os.path.join(root, f), remoteName) == False): |
| return None |
| return remoteDir |
| |
| def dirExists(self, dirname): |
| """ |
| Checks if dirname exists and is a directory |
| on the device file system |
| |
| returns: |
| success: True |
| failure: False |
| """ |
| match = ".*" + dirname.replace('^', '\^') + "$" |
| dirre = re.compile(match) |
| try: |
| data = self._runCmds([{'cmd': 'cd ' + dirname}, {'cmd': 'cwd'}]) |
| except AgentError: |
| return False |
| |
| found = False |
| for d in data.splitlines(): |
| if (dirre.match(d)): |
| found = True |
| |
| return found |
| |
| # Because we always have / style paths we make this a lot easier with some |
| # assumptions |
| def fileExists(self, filepath): |
| """ |
| Checks if filepath exists and is a file on |
| the device file system |
| |
| returns: |
| success: True |
| failure: False |
| """ |
| s = filepath.split('/') |
| containingpath = '/'.join(s[:-1]) |
| listfiles = self.listFiles(containingpath) |
| for f in listfiles: |
| if (f == s[-1]): |
| return True |
| return False |
| |
| def listFiles(self, rootdir): |
| """ |
| Lists files on the device rootdir |
| |
| returns: |
| success: array of filenames, ['file1', 'file2', ...] |
| failure: None |
| """ |
| rootdir = rootdir.rstrip('/') |
| if (self.dirExists(rootdir) == False): |
| return [] |
| try: |
| data = self._runCmds([{'cmd': 'cd ' + rootdir}, {'cmd': 'ls'}]) |
| except AgentError: |
| return [] |
| |
| files = filter(lambda x: x, data.splitlines()) |
| if len(files) == 1 and files[0] == '<empty>': |
| # special case on the agent: empty directories return just the |
| # string "<empty>" |
| return [] |
| return files |
| |
| def removeFile(self, filename): |
| """ |
| Removes filename from the device |
| |
| returns: |
| success: output of telnet |
| failure: None |
| """ |
| if (self.debug >= 2): |
| print "removing file: " + filename |
| try: |
| retVal = self._runCmds([{'cmd': 'rm ' + filename}]) |
| except AgentError: |
| return None |
| |
| return retVal |
| |
| def removeDir(self, remoteDir): |
| """ |
| Does a recursive delete of directory on the device: rm -Rf remoteDir |
| |
| returns: |
| success: output of telnet |
| failure: None |
| """ |
| try: |
| retVal = self._runCmds([{'cmd': 'rmdr ' + remoteDir}]) |
| except AgentError: |
| return None |
| |
| return retVal |
| |
| def getProcessList(self): |
| """ |
| Lists the running processes on the device |
| |
| returns: |
| success: array of process tuples |
| failure: [] |
| """ |
| try: |
| data = self._runCmds([{'cmd': 'ps'}]) |
| except AgentError: |
| return [] |
| |
| files = [] |
| for line in data.splitlines(): |
| if line: |
| pidproc = line.strip().split() |
| if (len(pidproc) == 2): |
| files += [[pidproc[0], pidproc[1]]] |
| elif (len(pidproc) == 3): |
| # android returns <userID> <procID> <procName> |
| files += [[pidproc[1], pidproc[2], pidproc[0]]] |
| return files |
| |
| def fireProcess(self, appname, failIfRunning=False): |
| """ |
| DEPRECATED: Use shell() or launchApplication() for new code |
| |
| returns: |
| success: pid |
| failure: None |
| """ |
| if (not appname): |
| if (self.debug >= 1): |
| print "WARNING: fireProcess called with no command to run" |
| return None |
| |
| if (self.debug >= 2): |
| print "FIRE PROC: '" + appname + "'" |
| |
| if (self.processExist(appname) != None): |
| print "WARNING: process %s appears to be running already\n" % appname |
| if (failIfRunning): |
| return None |
| |
| try: |
| self._runCmds([{'cmd': 'exec ' + appname}]) |
| except AgentError: |
| return None |
| |
| # The 'exec' command may wait for the process to start and end, so checking |
| # for the process here may result in process = None. |
| process = self.processExist(appname) |
| if (self.debug >= 4): |
| print "got pid: %s for process: %s" % (process, appname) |
| |
| return process |
| |
| def launchProcess(self, cmd, outputFile="process.txt", cwd='', env='', failIfRunning=False): |
| """ |
| DEPRECATED: Use shell() or launchApplication() for new code |
| |
| returns: |
| success: output filename |
| failure: None |
| """ |
| if not cmd: |
| if (self.debug >= 1): |
| print "WARNING: launchProcess called without command to run" |
| return None |
| |
| cmdline = subprocess.list2cmdline(cmd) |
| if (outputFile == "process.txt" or outputFile == None): |
| outputFile = self.getDeviceRoot(); |
| if outputFile is None: |
| return None |
| outputFile += "/process.txt" |
| cmdline += " > " + outputFile |
| |
| # Prepend our env to the command |
| cmdline = '%s %s' % (self._formatEnvString(env), cmdline) |
| |
| if self.fireProcess(cmdline, failIfRunning) is None: |
| return None |
| return outputFile |
| |
| def killProcess(self, appname, forceKill=False): |
| """ |
| Kills the process named appname. |
| If forceKill is True, process is killed regardless of state |
| |
| returns: |
| success: True |
| failure: False |
| """ |
| if forceKill: |
| print "WARNING: killProcess(): forceKill parameter unsupported on SUT" |
| try: |
| self._runCmds([{'cmd': 'kill ' + appname}]) |
| except AgentError: |
| return False |
| |
| return True |
| |
| def getTempDir(self): |
| """ |
| Gets the temporary directory we are using on this device |
| base on our device root, ensuring also that it exists. |
| |
| returns: |
| success: path for temporary directory |
| failure: None |
| """ |
| try: |
| data = self._runCmds([{'cmd': 'tmpd'}]) |
| except AgentError: |
| return None |
| |
| return data.strip() |
| |
| def catFile(self, remoteFile): |
| """ |
| Returns the contents of remoteFile |
| |
| returns: |
| success: filecontents, string |
| failure: None |
| """ |
| try: |
| data = self._runCmds([{'cmd': 'cat ' + remoteFile}]) |
| except AgentError: |
| return None |
| |
| return data |
| |
| def pullFile(self, remoteFile): |
| """ |
| Returns contents of remoteFile using the "pull" command. |
| |
| returns: |
| success: output of pullfile, string |
| failure: None |
| """ |
| # The "pull" command is different from other commands in that DeviceManager |
| # has to read a certain number of bytes instead of just reading to the |
| # next prompt. This is more robust than the "cat" command, which will be |
| # confused if the prompt string exists within the file being catted. |
| # However it means we can't use the response-handling logic in |
| # sendCMD(). |
| |
| def err(error_msg): |
| err_str = 'DeviceManager: pull unsuccessful: %s' % error_msg |
| print err_str |
| self._sock = None |
| raise FileError(err_str) |
| |
| # FIXME: We could possibly move these socket-reading functions up to |
| # the class level if we wanted to refactor sendCMD(). For now they are |
| # only used to pull files. |
| |
| def uread(to_recv, error_msg, timeout=None): |
| """ unbuffered read """ |
| timer = 0 |
| select_timeout = 1 |
| if not timeout: |
| timeout = self.default_timeout |
| |
| try: |
| if select.select([self._sock], [], [], select_timeout)[0]: |
| data = self._sock.recv(to_recv) |
| timer = 0 |
| timer += select_timeout |
| if timer > timeout: |
| err('timeout in uread while retrieving file') |
| return None |
| |
| if not data: |
| err(error_msg) |
| return None |
| return data |
| except: |
| err(error_msg) |
| return None |
| |
| def read_until_char(c, buf, error_msg): |
| """ read until 'c' is found; buffer rest """ |
| while not '\n' in buf: |
| data = uread(1024, error_msg) |
| if data == None: |
| err(error_msg) |
| return ('', '', '') |
| buf += data |
| return buf.partition(c) |
| |
| def read_exact(total_to_recv, buf, error_msg): |
| """ read exact number of 'total_to_recv' bytes """ |
| while len(buf) < total_to_recv: |
| to_recv = min(total_to_recv - len(buf), 1024) |
| data = uread(to_recv, error_msg) |
| if data == None: |
| return None |
| buf += data |
| return buf |
| |
| prompt = self.base_prompt + self.prompt_sep |
| buf = '' |
| |
| # expected return value: |
| # <filename>,<filesize>\n<filedata> |
| # or, if error, |
| # <filename>,-1\n<error message> |
| try: |
| # just send the command first, we read the response inline below |
| self._runCmds([{'cmd': 'pull ' + remoteFile}]) |
| except AgentError: |
| return None |
| |
| # read metadata; buffer the rest |
| metadata, sep, buf = read_until_char( |
| '\n', buf, 'could not find metadata') |
| if not metadata: |
| return None |
| if self.debug >= 3: |
| print 'metadata: %s' % metadata |
| |
| filename, sep, filesizestr = metadata.partition(',') |
| if sep == '': |
| err('could not find file size in returned metadata') |
| return None |
| try: |
| filesize = int(filesizestr) |
| except ValueError: |
| err('invalid file size in returned metadata') |
| return None |
| |
| if filesize == -1: |
| # read error message |
| error_str, sep, buf = read_until_char( |
| '\n', buf, 'could not find error message') |
| if not error_str: |
| return None |
| # prompt should follow |
| read_exact(len(prompt), buf, 'could not find prompt') |
| # failures are expected, so don't use "Remote Device Error" or |
| # we'll RETRY |
| print "DeviceManager: pulling file '%s' unsuccessful: %s" % (remoteFile, error_str) |
| return None |
| |
| # read file data |
| total_to_recv = filesize + len(prompt) |
| buf = read_exact(total_to_recv, buf, 'could not get all file data') |
| if buf == None: |
| return None |
| if buf[-len(prompt):] != prompt: |
| err('no prompt found after file data--DeviceManager may be out of sync with agent') |
| return buf |
| return buf[:-len(prompt)] |
| |
| def getFile(self, remoteFile, localFile=''): |
| """ |
| Copy file from device (remoteFile) to host (localFile) |
| |
| returns: |
| success: contents of file, string |
| failure: None |
| """ |
| if localFile == '': |
| localFile = os.path.join(self.tempRoot, "temp.txt") |
| |
| try: |
| retVal = self.pullFile(remoteFile) |
| except: |
| return None |
| |
| if (retVal is None): |
| return None |
| |
| fhandle = open(localFile, 'wb') |
| fhandle.write(retVal) |
| fhandle.close() |
| if not self.validateFile(remoteFile, localFile): |
| print 'DeviceManager: failed to validate file when downloading %s' % remoteFile |
| return None |
| return retVal |
| |
| def getDirectory(self, remoteDir, localDir, checkDir=True): |
| """ |
| Copy directory structure from device (remoteDir) to host (localDir) |
| |
| returns: |
| success: list of files, string |
| failure: None |
| """ |
| if (self.debug >= 2): |
| print "getting files in '" + remoteDir + "'" |
| if checkDir: |
| try: |
| is_dir = self.isDir(remoteDir) |
| except FileError: |
| return None |
| if not is_dir: |
| return None |
| |
| filelist = self.listFiles(remoteDir) |
| if (self.debug >= 3): |
| print filelist |
| if not os.path.exists(localDir): |
| os.makedirs(localDir) |
| |
| for f in filelist: |
| if f == '.' or f == '..': |
| continue |
| remotePath = remoteDir + '/' + f |
| localPath = os.path.join(localDir, f) |
| try: |
| is_dir = self.isDir(remotePath) |
| except FileError: |
| print 'isdir failed on file "%s"; continuing anyway...' % remotePath |
| continue |
| if is_dir: |
| if (self.getDirectory(remotePath, localPath, False) == None): |
| print 'Remote Device Error: failed to get directory "%s"' % remotePath |
| return None |
| else: |
| # It's sometimes acceptable to have getFile() return None, such as |
| # when the agent encounters broken symlinks. |
| # FIXME: This should be improved so we know when a file transfer really |
| # failed. |
| if self.getFile(remotePath, localPath) == None: |
| print 'failed to get file "%s"; continuing anyway...' % remotePath |
| return filelist |
| |
| def isDir(self, remotePath): |
| """ |
| Checks if remotePath is a directory on the device |
| |
| returns: |
| success: True |
| failure: False |
| """ |
| try: |
| data = self._runCmds([{'cmd': 'isdir ' + remotePath}]) |
| except AgentError: |
| # normally there should be no error here; a nonexistent file/directory will |
| # return the string "<filename>: No such file or directory". |
| # However, I've seen AGENT-WARNING returned before. |
| return False |
| |
| retVal = data.strip() |
| if not retVal: |
| raise FileError('isdir returned null') |
| return retVal == 'TRUE' |
| |
| def validateFile(self, remoteFile, localFile): |
| """ |
| Checks if the remoteFile has the same md5 hash as the localFile |
| |
| returns: |
| success: True |
| failure: False |
| """ |
| remoteHash = self._getRemoteHash(remoteFile) |
| localHash = self._getLocalHash(localFile) |
| |
| if (remoteHash == None): |
| return False |
| |
| if (remoteHash == localHash): |
| return True |
| |
| return False |
| |
| def _getRemoteHash(self, filename): |
| """ |
| Return the md5 sum of a file on the device |
| |
| returns: |
| success: MD5 hash for given filename |
| failure: None |
| """ |
| try: |
| data = self._runCmds([{'cmd': 'hash ' + filename}]) |
| except AgentError: |
| return None |
| |
| retVal = None |
| if data: |
| retVal = data.strip() |
| if self.debug >= 3: |
| print "remote hash returned: '%s'" % retVal |
| return retVal |
| |
| def getDeviceRoot(self): |
| """ |
| Gets the device root for the testing area on the device |
| For all devices we will use / type slashes and depend on the device-agent |
| to sort those out. The agent will return us the device location where we |
| should store things, we will then create our /tests structure relative to |
| that returned path. |
| Structure on the device is as follows: |
| /tests |
| /<fennec>|<firefox> --> approot |
| /profile |
| /xpcshell |
| /reftest |
| /mochitest |
| |
| returns: |
| success: path for device root |
| failure: None |
| """ |
| if self.deviceRoot: |
| deviceRoot = self.deviceRoot |
| else: |
| try: |
| data = self._runCmds([{'cmd': 'testroot'}]) |
| except BaseException as e: |
| print "Caught Exception:", e |
| return None |
| |
| deviceRoot = data.strip() + '/tests' |
| |
| if (not self.dirExists(deviceRoot)): |
| if (self.mkDir(deviceRoot) == None): |
| return None |
| |
| self.deviceRoot = deviceRoot |
| return self.deviceRoot |
| |
| def getAppRoot(self, packageName): |
| """ |
| Returns the app root directory |
| E.g /tests/fennec or /tests/firefox |
| |
| returns: |
| success: path for app root |
| failure: None |
| """ |
| try: |
| data = self._runCmds([{'cmd': 'getapproot ' + packageName}]) |
| except: |
| return None |
| |
| return data.strip() |
| |
| def unpackFile(self, file_path, dest_dir=None): |
| """ |
| Unzips a remote bundle to a remote location |
| If dest_dir is not specified, the bundle is extracted |
| in the same directory |
| |
| returns: |
| success: output of unzip command |
| failure: None |
| """ |
| devroot = self.getDeviceRoot() |
| if (devroot == None): |
| return None |
| |
| # if no dest_dir is passed in just set it to file_path's folder |
| if not dest_dir: |
| dest_dir = posixpath.dirname(file_path) |
| |
| if dest_dir[-1] != '/': |
| dest_dir += '/' |
| |
| try: |
| data = self._runCmds( |
| [{'cmd': 'unzp %s %s' % (file_path, dest_dir)}]) |
| except AgentError: |
| return None |
| |
| return data |
| |
| def reboot(self, ipAddr=None, port=30000): |
| """ |
| Reboots the device |
| |
| returns: |
| success: status from test agent |
| failure: None |
| """ |
| cmd = 'rebt' |
| |
| if (self.debug > 3): |
| print "INFO: sending rebt command" |
| |
| if (ipAddr is not None): |
| # create update.info file: |
| try: |
| destname = '/data/data/com.mozilla.SUTAgentAndroid/files/update.info' |
| data = "%s,%s\rrebooting\r" % (ipAddr, port) |
| self._runCmds([{'cmd': 'push %s %s' % ( |
| destname, len(data)), 'data': data}]) |
| except AgentError: |
| return None |
| |
| ip, port = self._getCallbackIpAndPort(ipAddr, port) |
| cmd += " %s %s" % (ip, port) |
| # Set up our callback server |
| callbacksvr = callbackServer(ip, port, self.debug) |
| |
| try: |
| status = self._runCmds([{'cmd': cmd}]) |
| except AgentError: |
| return None |
| |
| if (ipAddr is not None): |
| status = callbacksvr.disconnect() |
| |
| if (self.debug > 3): |
| print "INFO: rebt- got status back: " + str(status) |
| return status |
| |
| def getInfo(self, directive=None): |
| """ |
| Returns information about the device: |
| Directive indicates the information you want to get, your choices are: |
| os - name of the os |
| id - unique id of the device |
| uptime - uptime of the device |
| uptimemillis - uptime of the device in milliseconds (NOT supported on all implementations) |
| systime - system time of the device |
| screen - screen resolution |
| memory - memory stats |
| process - list of running processes (same as ps) |
| disk - total, free, available bytes on disk |
| power - power status (charge, battery temp) |
| all - all of them - or call it with no parameters to get all the information |
| |
| returns: |
| success: dict of info strings by directive name |
| failure: None |
| """ |
| data = None |
| result = {} |
| collapseSpaces = re.compile(' +') |
| |
| directives = [ |
| 'os', 'id', 'uptime', 'uptimemillis', 'systime', 'screen', |
| 'rotation', 'memory', 'process', 'disk', 'power'] |
| if (directive in directives): |
| directives = [directive] |
| |
| for d in directives: |
| try: |
| data = self._runCmds([{'cmd': 'info ' + d}]) |
| except AgentError: |
| return result |
| |
| if (data is None): |
| continue |
| data = collapseSpaces.sub(' ', data) |
| result[d] = data.split('\n') |
| |
| # Get rid of any 0 length members of the arrays |
| for k, v in result.iteritems(): |
| result[k] = filter(lambda x: x != '', result[k]) |
| |
| # Format the process output |
| if 'process' in result: |
| proclist = [] |
| for l in result['process']: |
| if l: |
| proclist.append(l.split('\t')) |
| result['process'] = proclist |
| |
| if (self.debug >= 3): |
| print "results: " + str(result) |
| return result |
| |
| def installApp(self, appBundlePath, destPath=None): |
| """ |
| Installs an application onto the device |
| appBundlePath - path to the application bundle on the device |
| destPath - destination directory of where application should be installed to (optional) |
| |
| returns: |
| success: None |
| failure: error string |
| """ |
| cmd = 'inst ' + appBundlePath |
| if destPath: |
| cmd += ' ' + destPath |
| |
| try: |
| data = self._runCmds([{'cmd': cmd}]) |
| except AgentError, err: |
| print "Remote Device Error: Error installing app: %s" % err |
| return "%s" % err |
| |
| f = re.compile('Failure') |
| for line in data.split(): |
| if (f.match(line)): |
| return line |
| return None |
| |
| def uninstallApp(self, appName, installPath=None): |
| """ |
| Uninstalls the named application from device and DOES NOT cause a reboot |
| appName - the name of the application (e.g org.mozilla.fennec) |
| installPath - the path to where the application was installed (optional) |
| |
| returns: |
| success: None |
| failure: DMError exception thrown |
| """ |
| cmd = 'uninstall ' + appName |
| if installPath: |
| cmd += ' ' + installPath |
| try: |
| data = self._runCmds([{'cmd': cmd}]) |
| except AgentError, err: |
| raise DMError( |
| "Remote Device Error: Error uninstalling all %s" % appName) |
| |
| status = data.split('\n')[0].strip() |
| if self.debug > 3: |
| print "uninstallApp: '%s'" % status |
| if status == 'Success': |
| return |
| raise DMError("Remote Device Error: uninstall failed for %s" % appName) |
| |
| def uninstallAppAndReboot(self, appName, installPath=None): |
| """ |
| Uninstalls the named application from device and causes a reboot |
| appName - the name of the application (e.g org.mozilla.fennec) |
| installPath - the path to where the application was installed (optional) |
| |
| returns: |
| success: None |
| failure: DMError exception thrown |
| """ |
| cmd = 'uninst ' + appName |
| if installPath: |
| cmd += ' ' + installPath |
| try: |
| data = self._runCmds([{'cmd': cmd}]) |
| except AgentError: |
| raise DMError( |
| "Remote Device Error: uninstall failed for %s" % appName) |
| |
| if (self.debug > 3): |
| print "uninstallAppAndReboot: " + str(data) |
| return |
| |
| def updateApp(self, appBundlePath, processName=None, destPath=None, ipAddr=None, port=30000): |
| """ |
| Updates the application on the device. |
| appBundlePath - path to the application bundle on the device |
| processName - used to end the process if the applicaiton is currently running (optional) |
| destPath - Destination directory to where the application should be installed (optional) |
| ipAddr - IP address to await a callback ping to let us know that the device has updated |
| properly - defaults to current IP. |
| port - port to await a callback ping to let us know that the device has updated properly |
| defaults to 30000, and counts up from there if it finds a conflict |
| |
| returns: |
| success: text status from command or callback server |
| failure: None |
| """ |
| status = None |
| cmd = 'updt ' |
| if (processName == None): |
| # Then we pass '' for processName |
| cmd += "'' " + appBundlePath |
| else: |
| cmd += processName + ' ' + appBundlePath |
| |
| if (destPath): |
| cmd += " " + destPath |
| |
| if (ipAddr is not None): |
| ip, port = self._getCallbackIpAndPort(ipAddr, port) |
| cmd += " %s %s" % (ip, port) |
| # Set up our callback server |
| callbacksvr = callbackServer(ip, port, self.debug) |
| |
| if (self.debug >= 3): |
| print "INFO: updateApp using command: " + str(cmd) |
| |
| try: |
| status = self._runCmds([{'cmd': cmd}]) |
| except AgentError: |
| return None |
| |
| if ipAddr is not None: |
| status = callbacksvr.disconnect() |
| |
| if (self.debug >= 3): |
| print "INFO: updateApp: got status back: " + str(status) |
| |
| return status |
| |
| def getCurrentTime(self): |
| """ |
| Returns device time in milliseconds since the epoch |
| |
| returns: |
| success: time in ms |
| failure: None |
| """ |
| try: |
| data = self._runCmds([{'cmd': 'clok'}]) |
| except AgentError: |
| return None |
| |
| return data.strip() |
| |
| def _getCallbackIpAndPort(self, aIp, aPort): |
| """ |
| Connect the ipaddress and port for a callback ping. Defaults to current IP address |
| And ports starting at 30000. |
| NOTE: the detection for current IP address only works on Linux! |
| """ |
| ip = aIp |
| nettools = NetworkTools() |
| if (ip == None): |
| ip = nettools.getLanIp() |
| if (aPort != None): |
| port = nettools.findOpenPort(ip, aPort) |
| else: |
| port = nettools.findOpenPort(ip, 30000) |
| return ip, port |
| |
| def _formatEnvString(self, env): |
| """ |
| Returns a properly formatted env string for the agent. |
| Input - env, which is either None, '', or a dict |
| Output - a quoted string of the form: '"envvar1=val1,envvar2=val2..."' |
| If env is None or '' return '' (empty quoted string) |
| """ |
| if (env == None or env == ''): |
| return '' |
| |
| retVal = '"%s"' % ','.join( |
| map(lambda x: '%s=%s' % (x[0], x[1]), env.iteritems())) |
| if (retVal == '""'): |
| return '' |
| |
| return retVal |
| |
| def adjustResolution(self, width=1680, height=1050, type='hdmi'): |
| """ |
| adjust the screen resolution on the device, REBOOT REQUIRED |
| NOTE: this only works on a tegra ATM |
| return: |
| success: True |
| failure: False |
| |
| supported resolutions: 640x480, 800x600, 1024x768, 1152x864, 1200x1024, 1440x900, 1680x1050, 1920x1080 |
| """ |
| if self.getInfo('os')['os'][0].split()[0] != 'harmony-eng': |
| if (self.debug >= 2): |
| print "WARNING: unable to adjust screen resolution on non Tegra device" |
| return False |
| |
| results = self.getInfo('screen') |
| parts = results['screen'][0].split(':') |
| if (self.debug >= 3): |
| print "INFO: we have a current resolution of %s, %s" % (parts[1].split()[0], parts[2].split()[0]) |
| |
| # verify screen type is valid, and set it to the proper value |
| # (https://bugzilla.mozilla.org/show_bug.cgi?id=632895#c4) |
| screentype = -1 |
| if (type == 'hdmi'): |
| screentype = 5 |
| elif (type == 'vga' or type == 'crt'): |
| screentype = 3 |
| else: |
| return False |
| |
| # verify we have numbers |
| if not (isinstance(width, int) and isinstance(height, int)): |
| return False |
| |
| if (width < 100 or width > 9999): |
| return False |
| |
| if (height < 100 or height > 9999): |
| return False |
| |
| if (self.debug >= 3): |
| print "INFO: adjusting screen resolution to %s, %s and rebooting" % (width, height) |
| try: |
| self._runCmds([{'cmd': "exec setprop persist.tegra.dpy%s.mode.width %s" % (screentype, width)}]) |
| self._runCmds([{'cmd': "exec setprop persist.tegra.dpy%s.mode.height %s" % (screentype, height)}]) |
| except AgentError: |
| return False |
| |
| return True |
| |
| def chmodDir(self, remoteDir, **kwargs): |
| """ |
| Recursively changes file permissions in a directory |
| |
| returns: |
| success: True |
| failure: False |
| """ |
| try: |
| self._runCmds([{'cmd': "chmod " + remoteDir}]) |
| except AgentError: |
| return False |
| return True |
| |
| gCallbackData = '' |
| |
| |
| class myServer(SocketServer.TCPServer): |
| allow_reuse_address = True |
| |
| |
| class callbackServer(): |
| def __init__(self, ip, port, debuglevel): |
| global gCallbackData |
| if (debuglevel >= 1): |
| print "DEBUG: gCallbackData is: %s on port: %s" % (gCallbackData, port) |
| gCallbackData = '' |
| self.ip = ip |
| self.port = port |
| self.connected = False |
| self.debug = debuglevel |
| if (self.debug >= 3): |
| print "Creating server with " + str(ip) + ":" + str(port) |
| self.server = myServer((ip, port), self.myhandler) |
| self.server_thread = Thread(target=self.server.serve_forever) |
| self.server_thread.setDaemon(True) |
| self.server_thread.start() |
| |
| def disconnect(self, step=60, timeout=600): |
| t = 0 |
| if (self.debug >= 3): |
| print "Calling disconnect on callback server" |
| while t < timeout: |
| if (gCallbackData): |
| # Got the data back |
| if (self.debug >= 3): |
| print "Got data back from agent: " + str(gCallbackData) |
| break |
| else: |
| if (self.debug >= 0): |
| print '.', |
| time.sleep(step) |
| t += step |
| |
| try: |
| if (self.debug >= 3): |
| print "Shutting down server now" |
| self.server.shutdown() |
| except: |
| if (self.debug >= 1): |
| print "Automation Error: Unable to shutdown callback server - check for a connection on port: " + str(self.port) |
| |
| # sleep 1 additional step to ensure not only we are online, but all our |
| # services are online |
| time.sleep(step) |
| return gCallbackData |
| |
| class myhandler(SocketServer.BaseRequestHandler): |
| def handle(self): |
| global gCallbackData |
| gCallbackData = self.request.recv(1024) |
| # print "Callback Handler got data: " + str(gCallbackData) |
| self.request.send("OK") |
