automate-standard-baseline 0.0.1

data/bin/abs-stop

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+
+require 'helpers'
+require 'logger'
+require 'yaml'
+require 'sys/proctable'
+require 'optparse'
+
+include Sys
+
+END {
+
+options = opt_parse(ARGV)
+
+pid_file = '.pid'
+
+unless File.exists?(pid_file)
+	log("pid file doesn't exist!")
+	exit 
+end
+
+pid_content = YAML.load_file(pid_file)
+options.each do |k, v|
+    str_key = k.to_s
+
+    str_key = 'main' if str_key == 'all'
+    str_key = v if str_key == 'serial'
+
+    log "Stopping '#{str_key}' processes"
+
+    pids = pid_content.delete(str_key)
+    do_stop(pids)
+end
+
+if not pid_content.empty? and options[:all].nil?
+    IO.write(pid_file, pid_content.to_yaml)
+else
+    File.delete(pid_file)
+end
+
+} # end of END
+
+def opt_parse(args)
+
+    options = {}
+
+    opts = OptionParser.new do |opt|
+        opt.banner = "Usage: stop [options]"
+        opt.separator ""
+
+        opt.on("-a", "--all", "Stop all processes [default]") do |v|
+            options[:all] = v
+        end
+
+        opt.on("-l", "--logcat", "Stop logcat processes") do |v|
+            options[:logcat] = v
+        end
+
+        opt.on("-t", "--tcpdump", "Stop tcpdump processes") do |v|
+            options[:tcpdump] = v
+        end
+
+        opt.on("-s", "--serial [SERIAL_NUMBER]", "Stop all processes related the specified device serial number") do |v|
+            options[:serial] = v
+        end
+
+        opt.separator ""
+        opt.on_tail("-h", "--help", "Show this message") do
+            puts opt
+            exit
+        end
+    end
+
+    opts.parse!(args)
+    # stop all processes by default
+    options[:all] = true if options.length == 0
+
+    options
+end
+
+def do_stop(pids)
+    return if pids.nil?
+
+	log "Stopping #{pids.to_s}"
+    to_kill = pids
+
+	# find the sub-processes of these pids
+    ProcTable.ps do |proc|
+        to_kill << proc.pid if to_kill.include?(proc.ppid)
+    end
+    log "Processes will be killed (including sub-processes): #{to_kill}"
+
+    to_kill.each do |pid|
+        Process.kill("KILL", pid) rescue nil # in case of the process doesn't exist. 
+    end
+    log "Done!"
+end
+
+

data/bin/automate-standard-baseline

@@ -0,0 +1,283 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+require 'operations'
+require 'helpers'
+require 'logger'
+require 'optparse'
+require 'ostruct'
+require "securerandom"
+require 'sys/proctable'
+
+include Sys
+
+include Seven::ASB::Operations
+
+
+$pid_file = '.pid'
+
+# For now we hard code the timeout value in case of the 
+# program run more than 24 hours
+$time_out = 24 * 60 * 60
+
+##-------------------------------------------------------------
+## define methods
+##-----------------
+def opt_parse(args)
+    # The options specified on the command line will be collected in *options*.
+    # We set default values here.
+    options = {}
+
+    mandatory = [:oc_path,:reinstall,:duration]
+    mutual_exclusion = [:oc_path,:reinstall,:duration]
+
+    # set default values
+    options[:enable_logcat] = true
+    options[:enable_tcpdump] = true
+
+    options[:enable_monitor] = false
+    options[:verbose] = true
+
+    opts = OptionParser.new do |opts|
+        opts.banner = "Usage: run [options]"
+
+        opts.separator ""
+        opts.separator "Specific options:"
+
+        # Mandatory argument.
+        opts.on("-l", "--[no-]logcat", "record logcat logs") do |v|
+            options[:enable_logcat] = v
+        end
+
+        opts.on("-t", "--[no-]tcpdump", "record tcpdump or not") do |v|
+            options[:enable_tcpdump] = v 
+        end
+
+
+        opts.on("-o", "--oc_path oc_path",
+            "specify oc client path(local file path or http url)") do |oc_path|
+            options[:oc_path] = oc_path 
+            options[:reinstall] = true if options[:reinstall].nil? # only when user doesn't use -n
+            # if user uses -n and -o together, only -n will take effect.
+        end     
+
+        opts.on("-n", "--no-reinstall", "Whether to re-install OC client or not") do 
+            options[:reinstall] = false 
+        end
+
+        
+        opts.on("-d [TIME_TO_TEST]", "test duration time") do |v|
+            v = v.strip
+            seconds = 0
+
+            case v
+            when /^(\d+)\s*(hours|hour|hrs|h|hr)?$/
+                seconds = $1.to_i * 60 * 60    
+            when /^(\d+)\s*(minute|minutes|m|ms)?$/
+                seconds = $1.to_i * 60
+            when /^(\d+)\s*(seconds|second|s)?$/
+                seconds = $1.to_i 
+            else
+                raise %Q{ The time value "#{v}" is not acceptable. }
+            end
+            options[:duration] = seconds
+        end  
+
+    end
+
+    opts.parse!(args)
+    missing = mandatory.select{ |param| options[param].nil? }
+    if missing.select{|i| mutual_exclusion.include?(i)} == mutual_exclusion
+        puts "One of #{mutual_exclusion.join(', ')} must be specified!"
+        puts opts
+        exit
+    end
+
+    missing.delete_if{|i| mutual_exclusion.include?(i)}
+    unless missing.empty?
+        puts "Missing options: #{missing.join(', ')}"
+        puts opts
+        exit
+    end
+
+    options
+    
+end 
+
+def trap_signals
+    Signal.trap("INT") do
+      logger.info "Terminating..."
+      to_kill = [Process.pid]
+      ProcTable.ps do |proc|
+          to_kill << proc.pid if to_kill.include?(proc.ppid)
+      end
+      logger.info "Processes will be killed (including sub-processes): #{to_kill}"
+      to_kill.each do |pid|
+          Process.kill("KILL", pid) rescue nil # in case of the process doesn't exist. 
+      end
+# process logcat
+# process execution status (if there is)
+      delete_pid_file($pid_file)
+      exit 1
+    end
+end
+
+def check_if_old_process_killed(pid_f)
+  if File.exists?(pid_f)
+    tmp_pid = YAML.load_file(pid_f)
+    tmp_pid.each do |k, v|
+      if v and not v.empty?   
+        logger.warn "Have you killed the old process properly?"
+        exit -1
+      end
+    end
+
+    File.delete(pid_f)
+  end
+end
+
+def delete_pid_file(pid_f)
+  if File.exists?(pid_f)
+    File.delete(pid_f)
+    end
+end
+
+def archive_logs(devices)
+# if there is any existing tcpdump files on devices' sdcard, pull them
+# out and archive them. In case of the program crashed or ubs exit 
+# abnormally, we'd better do this check.
+# All /sdcard/*.pcap will be pulled to logs and then removed.
+
+    logger.info "Check existing tcpdump...."
+    pull_out_tcpdump(devices)
+    logger.info "tcpdump checking done."
+
+  if Dir.exists?('logs')
+    # Archive the logs
+    archive_name = "#{Time.now.strftime('%Y%m_%d%H%M%S')}.tar.gz"
+    logger.info "archiving existing logs to #{archive_name}"
+    logger.info `tar --gzip --remove-files -cvf #{archive_name} logs` 
+
+    # Move the log to archived dir
+    archived = 'archived'
+    Dir.mkdir(archived) unless Dir.exists?(archived)
+    `mv #{archive_name} #{archived}/`
+  end
+
+  Dir.mkdir('logs') unless Dir.exists?('logs')
+end
+
+## operation steps ---start test ...
+
+trap_signals()
+
+option = opt_parse(ARGV)
+
+logger.info "#{option}"
+
+check_if_old_process_killed($pid_file)
+
+devices = get_available_devices
+raise "No device connected!" if devices.length == 0
+
+
+archive_logs(devices)
+
+if not option[:reinstall]
+    # pull OC out from one of the devices.
+    # If one of them doesn't have OC installed, just exit!
+    logger.info "Pull OC out from device."
+
+    apk_path = nil
+    devices.each do |serial|
+        begin
+            apk_path = pull_out_apk(serial, 'com.seven.asimov', 'tmp/oc.apk') # com.igatr10.to
+        rescue
+            raise %Q{Device "#{serial}" doesn't install OC, You cannot run this program without OC installed!}
+        end
+    end
+    option[:oc_path] = apk_path
+end
+
+
+all_pids = {}
+logcat_pids = []
+tcpdump_pids = []
+
+for i in 0...devices.length
+    pids = []
+
+  # install oc at first
+  logger.info "start to install oc for device '#{devices[i]}'"
+  
+  #set environment
+  set_env(devices[i],i)
+ 
+  
+  install_or_dump_oc_client(option[:oc_path],option[:reinstall])
+  reset_data()
+
+  if option[:enable_logcat]
+    logcat_pid = spawn("#{adb_cmd} -s #{devices[i]} logcat -v time", [:out, :err]=>["logs/logcat-device-#{devices[i]}.log", 'w']) 
+        logcat_pids << logcat_pid
+        pids << logcat_pid
+  end
+
+  if option[:enable_tcpdump]
+    tcpdump_pid = spawn("#{adb_cmd} -s #{devices[i]} shell su -c tcpdump -s 0 -i any -w /sdcard/#{Time.now.strftime('%Y%m%d%H%M%S')}.pcap", 
+                [:out, :err]=>["logs/tcpdump-device-#{devices[i]}.log", 'w']) 
+        tcpdump_pids << tcpdump_pid
+        pids << tcpdump_pid
+  end
+
+    all_pids.store(devices[i], pids)
+   
+end
+
+
+
+# persist the pids 
+all_pids.store("main", [Process.pid])
+#all_pids.store("ubs", ubs_pids)
+if option[:enable_logcat]
+    all_pids.store("logcat", logcat_pids)
+end
+
+if option[:enable_tcpdump]
+    all_pids.store('tcpdump', tcpdump_pids)
+end
+logger.info "subprocesses' pids: #{all_pids}"
+IO.write('.pid', all_pids.to_yaml)
+
+# Wait for all sub-processes to finish 
+du=option[:duration]
+
+
+if nil==du||du==0
+  logger.info "use default time out: 24 hours"
+else
+  $time_out= Integer(du)
+end
+
+begin Timeout.timeout($time_out) do
+  Process.waitall
+  end  
+rescue Timeout::Error
+  logger.info 'Test duartion has over, pull tcpdump.'
+  
+  pull_out_tcpdump(devices)
+  delete_pid_file($pid_file)
+
+  logger.info "Kill all sub_processes"
+  # find the sub-processes of these pids
+  to_kill = [Process.pid]
+  ProcTable.ps do |proc|
+      to_kill << proc.pid if to_kill.include?(proc.ppid)
+  end
+  logger.info "Processes will be killed (including sub-processes): #{to_kill}"
+  to_kill.each do |pid|
+      Process.kill("KILL", pid) rescue nil # in case of the process doesn't exist. 
+  end
+end
+
+

data/lib/helpers.rb

@@ -0,0 +1,226 @@
+require 'rubygems'
+require "securerandom"
+require 'rexml/document'
+require 'rexml/xpath'
+require 'tempfile'
+require "uri"
+require "net/http"
+require 'fileutils'
+
+include REXML
+
+def default_timeout_val
+    300
+end
+
+def logger
+	@logger ||= Logger.new(STDOUT)
+end
+
+def set_env(device_id,id)
+   ENV["ADB_DEVICE_ARG"]="#{device_id}"
+   ENV["ADB_DEVICE_INDEX"]="#{id}"
+end
+
+def log(message)
+    logger.info message
+end
+
+
+def pull_out_apk(device_serial, package_name, to_path = nil)
+    out_path = File.expand_path(to_path) if to_path
+    out_path ||= File.expand_path("#{package_name}.apk")
+    
+    if File.exists?(out_path)
+        new_name = "#{out_path}.#{Time.now.strftime('%Y%m%d%H%M%S%s%S')}"  
+        puts %Q{rename #{out_path} to #{new_name} since it already exists.}
+        File.rename(out_path, new_name)
+    end
+
+    for num in ['2', '1', '3']
+        begin
+            cmd = %Q{ #{adb_cmd(device_serial)} pull /data/app/#{package_name}-#{num}.apk #{out_path} }
+            exec_command(cmd, 120)
+        rescue
+        end
+
+        if File.exists?(out_path)
+            break
+        end
+    end
+
+    raise %Q{Failed to pull out the package "#{}"} unless File.exists?(out_path)
+    out_path
+end
+
+def mkdirs(path)
+    if(!File.directory?(path))
+        if(!mkdirs(File.dirname(path)))
+            return false;
+        end
+        Dir.mkdir(path)
+    end
+
+    return true
+end
+
+
+def get_available_devices
+  # grep the connected devices
+  cmd = "#{adb_cmd} devices | ruby -nae 'puts $F[0] if $F[1] =~ /device/'" 
+    devices = exec_command(cmd, 10).output
+  devices = devices.split /\s+/
+
+  if devices.length > 0
+    logger.info {
+      msg = "\nAvailable devices\n"
+      for i in 0...devices.length
+        msg += "#{devices[i]}\n"
+      end
+
+      msg
+    }
+  end
+
+  devices
+end
+
+# pull out all /sdcard/*.pcap to logs/
+def pull_out_tcpdump(devices)
+    dest_dir = "/sdcard/"
+    devices.each do |d|
+        cmd = "#{adb_cmd(d)} shell su -c ls #{dest_dir} | grep pcap" 
+        tcpdump_files = exec_command(cmd, 10).output.strip
+        tcpdump_files.each_line do |f|
+            Dir.mkdir('logs') unless Dir.exists?('logs')
+
+            cmd = "#{adb_cmd(d)} pull #{File.join(dest_dir, f)} logs/#{d}_#{f}"
+            logger.info(cmd)
+            exec_command(cmd, 120)
+            cmd = "#{adb_cmd(d)} shell su -c rm #{File.join(dest_dir, f)}"
+            logger.info(cmd)
+            exec_command(cmd, 10)
+        end
+    end
+end
+
+
+def download_file(url, saved_path = nil)
+  uri = URI.parse(url)
+  path = (!uri.query or uri.query.blank?) ? uri.path : uri.path+"?"+uri.query
+  unless saved_path
+    saved_path = "oc_apks/#{uri.path[uri.path.rindex("/") + 1, uri.path.length]}"
+  end
+  saved_path = File.expand_path(saved_path)
+  puts "Download file by url #{url}; saved_path: #{saved_path}"
+  f = File.new(saved_path, "wb")
+  begin
+  print "Downloading\n"
+  i = 0
+  Net::HTTP.start(uri.host, uri.port) do |http|
+    http.request_get(path) do |resp|
+      resp.read_body do |segment|
+        f.write(segment)
+        i = i + 1
+        if (i % 80 == 0)
+          print "\n"
+        else 
+          print "."
+        end
+      end
+    end
+  end
+  ensure
+    f.close()
+  end
+  print "\n"
+  return saved_path
+end
+
+
+def package_name(app)
+  require 'rexml/document'
+  require 'rexml/xpath'
+
+  manifest = Document.new(manifest(app))
+  manifest.root.attributes['package']
+end
+
+def manifest(app)
+  cmd = %Q{java -jar "#{File.dirname(__FILE__)}/manifest_extractor.jar" "#{app}"}
+  puts "exec #{cmd}"
+  exec_command(cmd, default_timeout_val).output
+end
+
+class ExecResult
+  attr_accessor :output, :is_success, :status_code
+
+  def initialize(output, is_success, status_code)
+    @output = output
+    @is_success = is_success
+    @status_code = status_code
+  end
+end
+
+## Add timeout mechanism here to avoid external command executing the whole
+## program.
+def exec_command(cmd, time_out = nil)
+  rd, wr = IO.pipe
+  pid = spawn(cmd, [:out, :err] => wr)
+
+  begin
+      unless time_out
+        Process.waitpid(pid)
+        status_code = $?.exitstatus
+      else 
+        begin
+          Timeout.timeout(time_out) do
+            Process.waitpid(pid)
+            status_code = $?.exitstatus
+          end
+        rescue Timeout::Error => e
+          puts 'Timeout::Error'
+          puts "kill"
+          Process.kill("KILL", pid) rescue nil
+          status_code = -99999
+
+          backtrace = e.backtrace || []
+          new_error = Timeout::Error.new("Failed to execute command #{cmd} due to it spent too much time than expected time: #{time_out}s")
+          new_error.set_backtrace(backtrace + [e.message])
+
+          raise new_error
+        end
+      end
+  ensure
+      wr.close
+      output = rd.read
+      rd.close
+  end
+
+  ExecResult.new(output, status_code == 0, status_code)
+end
+
+
+
+def is_windows?
+  require 'rbconfig'
+  (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+end
+
+def adb_cmd(device_serial = nil)
+  if is_windows?
+    %Q("#{ENV["ANDROID_HOME"]}\\platform-tools\\adb.exe" #{_device_args(device_serial)}) 
+  else
+    %Q("#{ENV["ANDROID_HOME"]}/platform-tools/adb" #{_device_args(device_serial)})
+  end
+end
+
+def _device_args(device_serial = nil)
+  if ENV["ADB_DEVICE_ARG"]
+    "-s #{ENV["ADB_DEVICE_ARG"]}"
+  elsif device_serial
+    " -s #{device_serial} "
+  else
+    ""
+  end
+end

data/lib/operations.rb

@@ -0,0 +1,238 @@
+require 'net/http'
+require 'open-uri'
+require 'rubygems'
+require 'timeout'
+require 'retriable'
+require 'yaml'
+require 'uri'
+require File.join(File.dirname(__FILE__), "helpers")
+
+
+module Seven module ASB
+
+OC_GA_PROCESSES = ['occ', 'ochttpd', 'ocdnsd', 'ocshttpd', 'octcpd']
+
+module Operations
+
+  @@default_device = nil
+
+  @@default_time_out = 300 # 5 minutes
+  
+  def default_device
+    unless @@default_device
+      puts "create a default device"
+      @@default_device = Device.new(self, ENV['ADB_DEVICE_ARG'],ENV['ADB_DEVICE_INDEX'])
+    end
+    @@default_device
+  end
+
+
+  def install_or_dump_oc_client(path, reinstall = true)
+    
+    
+    if reinstall
+        uri = URI.parse(path)
+        if uri.scheme == 'http' or uri.scheme == 'https'
+            install_and_start_oc_client_by_url(path)
+        else
+            install_and_start_oc_client(path)
+        end
+    else
+        #log "Only dump the OC info but not re-install OC client."
+        #oc_info = dump_oc_info(path, "logs/device-#{ENV['ADB_DEVICE_ARG']}-oc-info.yml") 
+        #log "OC Info: #{oc_info}"
+    end
+  end
+
+  def reset_data()
+      # install the oc client apk
+    default_device.device_reset_data()
+      
+  end
+
+  def install_and_start_oc_client_by_url(url, saved_path = nil)
+    default_device.reinstall_oc_client_by_url(url, saved_path)
+  end
+
+  def install_and_start_oc_client(oc_apk_path)
+    default_device.reinstall_oc_client(oc_apk_path)
+  end 
+
+  def uninstall_oc_client(package_name)
+    default_device.uninstall_oc_client(package_name)
+  end
+
+  def start_oc_client()
+    default_device.start_oc_client()
+  end
+
+  def stop_oc_client(package_name)
+    default_device.stop_oc_client(package_name)
+  end
+
+ 
+
+  ###
+
+  class Device
+
+    def make_default_device
+      @cucumber_world.default_device = self
+    end
+
+    def initialize(cucumber_world, serial, index)
+      @cucumber_world = cucumber_world
+      @serial = serial
+      @index = index
+      log "ADB_DEVICE_INDEX; #{ENV['ADB_DEVICE_INDEX']}"
+      if @index
+        @index = Integer(@index) * 100 
+      else
+        @index = 0
+      end
+      log "device_index; #{@index}"
+	  @apps = Hash.new
+	 
+    end
+
+    
+    def uninstall_oc_client(package_name)
+      # uninstall the oc client apk
+      log "Uninstall oc client"
+      cmd = "#{adb_command} uninstall #{package_name}"
+      log cmd
+      result = exec_command(cmd, @@default_time_out)
+      log result.is_success
+      
+      stop_oc_client(package_name)
+
+      # remove /data/misc/openchannel
+      cmd = "#{adb_command} shell su -c rm -r /data/misc/openchannel"
+      log cmd
+      result = exec_command(cmd, @@default_time_out)
+      log result.is_success
+
+      cmd = "#{adb_command} shell su -c rm -r /sdcard/OpenChannel"
+      log cmd
+      result = exec_command(cmd, @@default_time_out)
+      log result.is_success
+
+      log "Uninstall oc client finished"
+    end
+
+    def start_oc_client()
+      log "Starting oc client...."
+      cmd = "#{adb_command} shell am startservice -a com.seven.asimov.ocengine.OCENGINESERVICE"
+      log cmd
+      result = exec_command(cmd, @@default_time_out)
+      raise "Can not start oc by am startservice" unless result.is_success
+ 
+      # check if oc is running
+      retriable :tries => 60, :interval => 30 do
+        cmd = "#{adb_command} shell su -c ps"
+        log cmd
+        result = exec_command(cmd, @@default_time_out)
+        for oc_process in OC_GA_PROCESSES
+          raise "OC client is not running" unless result.output.include?(oc_process)
+        end
+      end
+      
+      # check iptables is modified
+      retriable :tries => 60, :interval => 30 do
+        cmd = "#{adb_command} shell su -c iptables -t nat -nvL"
+        log cmd
+        result = exec_command(cmd, @@default_time_out)
+        raise "iptables is not modified" unless result.output.include?('redir ports 18080')
+      end
+      puts "oc client is started."  
+    end
+
+    def stop_oc_client(package_name)
+      log "Stopping oc client...."
+      cmd = "#{adb_command} shell am force-stop #{package_name}"
+      log cmd
+      result = exec_command(cmd, @@default_time_out)
+      log result.is_success
+      raise "Can not stop oc by am force-stop" unless result.is_success
+      
+      # kill oc client processes
+      for oc_process in OC_GA_PROCESSES
+        cmd = "#{adb_command} shell su -c cat /data/misc/openchannel/pids/#{oc_process}"
+        log cmd
+        result = exec_command(cmd, @@default_time_out).output.strip
+        log result
+        cmd = "#{adb_command} shell su -c kill -9 #{result}"
+        log cmd
+        result = exec_command(cmd, @@default_time_out)
+        log result.is_success
+      end
+
+      # flush iptables
+      cmd = "#{adb_command} shell su -c iptables -t nat -F"
+      log cmd
+      result = exec_command(cmd, @@default_time_out)
+      log result.is_success
+    end
+
+    def install_and_start_oc_client(oc_apk_path)
+      # install the oc client apk
+      log "Install oc client"
+      cmd = "#{adb_command} install -r #{oc_apk_path}"
+      log cmd
+      result = exec_command(cmd, @@default_time_out)
+      raise "Can not install oc client" unless result.is_success
+      start_oc_client()
+
+      #oc_info = dump_oc_info(oc_apk_path, "logs/device-#{ENV['ADB_DEVICE_ARG']}-oc-info.yml") 
+      #log "oc_info: #{oc_info}"
+      log "Install and start oc client finished."
+    end
+
+    def device_reset_data()
+      # install the oc client apk
+      log "Reset Data Usage/Mobile data (off/on)"
+      cmd = "#{adb_command} shell svc data disable && #{adb_command} shell svc data enable"
+      log cmd
+      result = exec_command(cmd, @@default_time_out)
+      raise "Can not reset data" unless result.is_success
+     
+      log "Reset data usage done."
+    end
+
+    def reinstall_oc_client(oc_apk_path)
+	  oc_pkg_name = package_name(oc_apk_path)
+      uninstall_oc_client(oc_pkg_name)
+      install_and_start_oc_client(oc_apk_path)
+    end
+
+    def reinstall_oc_client_by_url(url, saved_path = nil)
+      if saved_path
+        saved_path = File.expand_path(saved_path)
+      end
+      saved_path = download_file(url, saved_path)
+      reinstall_oc_client(saved_path)
+    end
+
+
+    def adb_command
+      if is_windows?
+        %Q("#{ENV["ANDROID_HOME"]}\\platform-tools\\adb.exe" #{device_args})
+      else
+        %Q("#{ENV["ANDROID_HOME"]}/platform-tools/adb" #{device_args})
+      end
+    end
+
+    def device_args
+      if @serial
+        "-s #{@serial}"
+      else
+        ""
+      end
+    end
+
+  end
+
+end
+
+
+end end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: automate-standard-baseline
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Richard Fu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &15690080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15690080
+description: auomated standard baseline test
+email: rfu@seven.com
+executables:
+- automate-standard-baseline
+- abs-stop
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/manifest_extractor.jar
+- lib/operations.rb
+- lib/helpers.rb
+- bin/automate-standard-baseline
+- bin/abs-stop
+homepage: http://rubygems.org/gems/automate-standard-baseline
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: automate-standard-baseline
+test_files: []