コード例 #1
0
def screenshot():
    path = PATH("%s/screenshot" % os.getcwd())
    utils.shell("screencap -p /data/local/tmp/tmp.png").wait()
    if not os.path.isdir(path):
        os.makedirs(path)

    utils.adb("pull /data/local/tmp/tmp.png %s" %
              PATH("%s/%s.png" % (path, utils.timestamp()))).wait()
    utils.shell("rm /data/local/tmp/tmp.png")
コード例 #2
0
  def terminate_instances(self, parameters):
    """
    Stop one of more EC2 instances using the ec2-terminate-instance command.
    The input instance IDs are fetched from the 'instance_ids' parameters
    in the input map. (Also see documentation for the BaseAgent class)

    Args:
      parameters  A dictionary of parameters
    """
    instance_ids = parameters[self.PARAM_INSTANCE_IDS]
    arg = ' '.join(instance_ids)
    utils.shell('{0}-terminate-instances {1} 2>&1'.format(self.prefix, arg))
コード例 #3
0
def record():
    utils.shell("screenrecord /data/local/tmp/video.mp4")
    input_key = raw_input("Please press the Enter key to stop recording:\n")
    if input_key == "":
        utils.adb("kill-server")

    print "Get Video file..."
    utils.adb("start-server")
    time.sleep(1.5)

    path = PATH("%s/video" % os.getcwd())
    if not os.path.isdir(path):
        os.makedirs(path)

    utils.adb("pull /data/local/tmp/video.mp4 %s" %
              PATH("%s/%s.mp4" % (path, utils.timestamp()))).wait()
コード例 #4
0
ファイル: fps.py プロジェクト: dcn01/AndroidTestingScripts
    def start_dump_latency_data(self, ignore_pending_fence_time=False):
        results = []
        if self.__clear_buffer():
            time.sleep(self.dump_time)
            results = utils.shell("{0} {1}".format(self.FRAME_LATENCY_CMD, self.activity_name))\
                .stdout.readlines()
            self.refresh_period = int(results[0].strip())

            if self.refresh_period < 0:
                return False

            data_invalid_flag = False
            for line in results:
                if not line.strip():
                    break

                if len(line.split()) == 1 or line.split()[0] == "0":
                    continue
                elif line.split()[1] == str(self.PENDING_FENCE_TIME):
                    if ignore_pending_fence_time:
                        data_invalid_flag = True
                    else:
                        return False

                self.frame_buffer_data.append(line.split())
                if not data_invalid_flag:
                    self.frame_latency_data_size += 1

            return True
コード例 #5
0
ファイル: getApp.py プロジェクト: dcn01/AndroidTestingScripts
def get_match_apk(package_name, path):
    list = []
    for packages in utils.shell("pm list packages -f %s" %package_name).stdout.readlines():
        if packages.split(":")[0] == "package":
            list.append(packages.split(":")[-1].split("=")[0])

    utils.adb("pull %s %s" % (list[0], path)).wait()
コード例 #6
0
def get_crash_log(time_list):
    log_file = PATH("%s/crash_log/%s.txt" % (os.getcwd(), utils.timestamp()))
    f = open(log_file, "w")
    for time in time_list:
        cash_log = utils.shell("dumpsys dropbox --print %s" %
                               time).stdout.read()
        f.write(cash_log)
    f.close()
コード例 #7
0
def get_match_apk(package_name):
    list = []
    for packages in utils.shell("pm list packages -f %s" %package_name).stdout.readlines():
        list.append(packages.split(":")[-1].split("=")[0])
    apk_name = list[0].split("/")[-1]

    utils.adb("pull %s %s" % (list[0], tempFile)).wait()

    return PATH("%s/%s" %(tempFile, apk_name))
コード例 #8
0
def get_permission_list(package_name):

    permission_list = []
    result_list = utils.shell(
        "dumpsys package %s | %s android.permission" %
        (package_name, utils.find_util)).stdout.readlines()

    for permission in result_list:
        permission_list.append(permission.strip())

    return permission_list
コード例 #9
0
def get_crash_time_list():
    time_list = []
    result_list = utils.shell("dumpsys dropbox | %s data_app_crash" %
                              utils.find_util).stdout.readlines()
    for time in result_list:
        temp_list = time.split(" ")
        temp_time = []
        temp_time.append(temp_list[0])
        temp_time.append(temp_list[1])
        time_list.append(" ".join(temp_time))

    return time_list
コード例 #10
0
def top():
    cpu = []
    mem = []

    top_info = utils.shell("top -n %s | %s %s$" % (str(times), utils.find_util, pkg_name)).stdout.readlines()
#  PID PR CPU% S #THR VSS RSS PCY UID Name
    for info in top_info:
        #temp_list = del_space(info)
        temp_list = info.split()
        cpu.append(temp_list[2])
        mem.append(temp_list[6])

    return (cpu, mem)
コード例 #11
0
  def describe_instances(self, parameters):
    """
    Execute the ec2-describe-instances command and returns a summary of the
    already running EC2 instances. (Also see documentation for the BaseAgent
    class)

    Args:
      parameters  A dictionary containing the 'keyname' parameter

    Returns:
      A tuple of the form (public_ips, private_ips, instances) where each
      member is a list.
    """
    keyname = parameters[self.PARAM_KEYNAME]
    describe_instances = utils.shell(self.prefix + '-describe-instances 2>&1')
    utils.log('describe-instances says {0}'.format(describe_instances))
    fqdn_regex = re.compile('\s+({0})\s+({0})\s+running\s+{1}\s'.format(self.FQDN_REGEX, keyname))
    instance_regex = re.compile('INSTANCE\s+(i-\w+)')
    all_ip_addresses = utils.flatten(fqdn_regex.findall(describe_instances))
    instances = utils.flatten(instance_regex.findall(describe_instances))
    public_ips, private_ips = self.get_ip_addresses(all_ip_addresses)
    return public_ips, private_ips, instances
コード例 #12
0
  def get_optimal_spot_price(self, instance_type):
    """
    Returns the spot price for an EC2 instance of the specified instance type.
    ec2-describe-spot-price-history command is used to obtain a set of spot
    prices from EC2 and the returned value is computed by averaging all the
    returned values and incrementing it by extra 20%.

    Args:
      instance_type An EC2 instance type

    Returns:
      The estimated spot price for the specified instance type
    """
    command = 'ec2-describe-spot-price-history -t {0} | grep \'Linux/UNIX\' | '\
              'awk \'{{print $2}}\''.format(instance_type)
    prices = utils.shell(command).split('\n')
    sum = 0.0
    for price in prices:
      sum += float(price)
    average = sum / len(prices)
    plus_twenty = average * 1.20
    utils.log('The average spot instance price for a {0} machine is {1}, '\
              'and 20% more is {2}'.format(instance_type, average, plus_twenty))
    return plus_twenty
コード例 #13
0
PATH = lambda p: os.path.abspath(p)


def record():
    utils.shell("screenrecord /data/local/tmp/video.mp4")
    input_key = raw_input("Please press the Enter key to stop recording:\n")
    if input_key == "":
        utils.adb("kill-server")

    print "Get Video file..."
    utils.adb("start-server")
    time.sleep(1.5)

    path = PATH("%s/video" % os.getcwd())
    if not os.path.isdir(path):
        os.makedirs(path)

    utils.adb("pull /data/local/tmp/video.mp4 %s" %
              PATH("%s/%s.mp4" % (path, utils.timestamp()))).wait()


if __name__ == "__main__":
    sdk = string.atoi(
        utils.shell("getprop ro.build.version.sdk").stdout.read())
    if sdk < 19:
        print ">>> sdk version is %s, less than 19!"
        sys.exit(0)
    else:
        record()
        print "Completed"
コード例 #14
0
  def run_instances(self, count, parameters, security_configured):
    """
    Spawn the specified number of EC2 instances using the parameters
    provided. This method relies on the ec2-run-instances command to
    spawn the actual VMs in the cloud. This method is blocking in that
    it waits until the requested VMs are properly booted up. However
    if the requested VMs cannot be procured within 1800 seconds, this
    method will treat it as an error and return. (Also see documentation
    for the BaseAgent class)

    Args:
      count               No. of VMs to spawned
      parameters          A dictionary of parameters. This must contain 'keyname',
                          'group', 'image_id' and 'instance_type' parameters.
      security_configured Uses this boolean value as an heuristic to
                          detect brand new AppScale deployments.

    Returns:
      A tuple of the form (instances, public_ips, private_ips)
    """
    image_id = parameters[self.PARAM_IMAGE_ID]
    instance_type = parameters[self.PARAM_INSTANCE_TYPE]
    keyname = parameters[self.PARAM_KEYNAME]
    group = parameters[self.PARAM_GROUP]
    spot = False

    utils.log('[{0}] [{1}] [{2}] [{3}] [ec2] [{4}] [{5}]'.format(count,
      image_id, instance_type, keyname, group, spot))

    start_time = datetime.datetime.now()
    active_public_ips = []
    active_private_ips = []
    active_instances = []
    if os.environ.has_key('EC2_URL'):
      utils.log('EC2_URL = [{0}]'.format(os.environ['EC2_URL']))
    else:
      utils.log('Warning: EC2_URL environment not found in the process runtime!')
    while True:
      active_public_ips, active_private_ips, active_instances =\
      self.describe_instances(parameters)
      # If security has been configured on this agent just now,
      # that's an indication that this is a fresh cloud deployment.
      # As such it's not expected to have any running VMs.
      if len(active_instances) > 0 or security_configured:
        break

    args = '-k {0} -n {1} --instance-type {2} --group {3} {4}'.format(keyname,
      count, instance_type, group, image_id)
    if spot:
      price = self.get_optimal_spot_price(instance_type)
      command_to_run = '{0}-request-spot-instances -p {1} {2}'.format(self.prefix, price, args)
    else:
      command_to_run = '{0}-run-instances {1}'.format(self.prefix, args)

    while True:
      run_instances = utils.shell(command_to_run)
      utils.log('Run instances says {0}'.format(run_instances))
      status, command_to_run = self.run_instances_response(command_to_run, run_instances)
      if status:
        break
      utils.log('sleepy time')
      utils.sleep(5)

    instances = []
    public_ips = []
    private_ips = []
    utils.sleep(10)

    end_time = datetime.datetime.now() + datetime.timedelta(0, self.MAX_VM_CREATION_TIME)
    now = datetime.datetime.now()
    while now < end_time:
      describe_instances = utils.shell(self.prefix + '-describe-instances 2>&1')
      utils.log('[{0}] {1} seconds left...'.format(now, (end_time - now).seconds))
      utils.log(describe_instances)
      fqdn_regex = re.compile('\s+({0})\s+({0})\s+running\s+{1}\s'.format(self.FQDN_REGEX, keyname))
      instance_regex = re.compile('INSTANCE\s+(i-\w+)')
      all_ip_addresses = utils.flatten(fqdn_regex.findall(describe_instances))
      instances = utils.flatten(instance_regex.findall(describe_instances))
      public_ips, private_ips = self.get_ip_addresses(all_ip_addresses)
      public_ips = utils.diff(public_ips, active_public_ips)
      private_ips = utils.diff(private_ips, active_private_ips)
      instances = utils.diff(instances, active_instances)
      if count == len(public_ips):
        break
      time.sleep(self.SLEEP_TIME)
      now = datetime.datetime.now()

    if not public_ips:
      sys.exit('No public IPs were able to be procured within the time limit')

    if len(public_ips) != count:
      for index in range(0, len(public_ips)):
        if public_ips[index] == '0.0.0.0':
          instance_to_term = instances[index]
          utils.log('Instance {0} failed to get a public IP address and is being terminated'.\
          format(instance_to_term))
          utils.shell(self.prefix + '-terminate-instances ' + instance_to_term)
      pass

    end_time = datetime.datetime.now()
    total_time = end_time - start_time
    if spot:
      utils.log('TIMING: It took {0} seconds to spawn {1} spot instances'.format(
        total_time.seconds, count))
    else:
      utils.log('TIMING: It took {0} seconds to spawn {1} regular instances'.format(
        total_time.seconds, count))
    return instances, public_ips, private_ips
コード例 #15
0
ファイル: fps.py プロジェクト: dcn01/AndroidTestingScripts
 def __clear_buffer(self):
     results = utils.shell("{0} {1}".format(self.CLEAR_BUFFER_CMD, self.activity_name))\
         .stdout.readlines()
     return not len(results)
コード例 #16
0
def get_apk_list():
    apps = []
    for apk in utils.shell("pm list packages -f -3").stdout.readlines():
        apps.append(apk.split(":")[-1].split("=")[0])
    return apps
コード例 #17
0
  def configure_instance_security(self, parameters):
    """
    Setup EC2 security keys and groups. Required input values are read from
    the parameters dictionary. More specifically, this method expects to
    find a 'keyname' parameter and a 'group' parameter in the parameters
    dictionary. Using these provided values, this method will create a new
    EC2 key-pair and a security group. Security group will be granted permissions
    to access any port on the instantiated VMs. (Also see documentation for the
    BaseAgent class)

    Args:
      parameters  A dictionary of parameters
    """
    keyname = parameters[self.PARAM_KEYNAME]
    group = parameters[self.PARAM_GROUP]
    ssh_key = os.path.abspath('/etc/appscale/keys/cloud1/{0}.key'.format(keyname))
    utils.log('About to spawn EC2 instances - Expecting to find a key at {0}'.format(ssh_key))
    utils.log(utils.get_obscured_env(['EC2_ACCESS_KEY', 'EC2_SECRET_KEY']))
    if not os.path.exists(ssh_key):
      utils.log('Creating keys/security group')
      ec2_output = ''
      while True:
        ec2_output = utils.shell('{0}-add-keypair {1} 2>&1'.format(self.prefix, keyname))
        if ec2_output.find('BEGIN RSA PRIVATE KEY') != -1:
          break
        utils.log('Trying again. Saw this from {0}-add-keypair: {1}'.format(
          self.prefix, ec2_output))
        utils.shell('{0}-delete-keypair {1} 2>&1'.format(self.prefix, keyname))
      utils.write_key_file(ssh_key, ec2_output)
      utils.shell('{0}-add-group {1} -d appscale 2>&1'.format(self.prefix, group))
      utils.shell('{0}-authorize {1} -p 1-65535 -P udp 2>&1'.format(self.prefix, group))
      utils.shell('{0}-authorize {1} -p 1-65535 -P tcp 2>&1'.format(self.prefix, group))
      utils.shell('{0}-authorize {1} -s 0.0.0.0/0 -P icmp -t -1:-1 2>&1'.format(self.prefix, group))
      return True
    else:
      utils.log('Not creating keys/security group')
      return False