droidspecter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5ae753d3428c78efecdfcdd2ec7446c450950ba
+  data.tar.gz: 639a541e93ae1999bd131c1339d234b27ec02929
+SHA512:
+  metadata.gz: 70dd3eefcb9e688114d38a49b6cd951a24e9df5679039fb4eef9a4bdbb8a94b587d99c731afd2c245bba8adbf6c03041b2f7484b13500bfa6d058d84d75ea8f6
+  data.tar.gz: 2b5319ad946df15cbe8b6dd10a1e24b37296377b82282a92d62a6bebfcb018baf5085de144cc86c667eb5c7b4d6841da6b6c645122e7ba3443495f5d78295832

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/droidrunner

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'droidrunner'
+
+Droidrunner.start(ARGV)

data/lib/droidrunner.rb

@@ -0,0 +1,169 @@
+require "thor"
+require "droidrunner/apprunner"
+require "droidrunner/vbmanager"
+require "droidrunner/adbrunner"
+require "droidrunner/devicemanager"
+
+class Droidrunner < Thor
+
+  option :execution_time, type: :numeric, default: 60, desc: "Time to execute app after monkey events"
+  option :monkey_events, type: :numeric, default: 500, desc: "Number of monkey events to execute"
+  option :vm_image_name, type: :string, default: "AndroidX86", desc: "Name of the VM to clone"
+  option :dedicated_vm, type: :boolean, default: false, desc: "If a dedicated VM should be created"
+  option :accelerate3d, type: :boolean, default: false, desc: "Turn on 3D acceleration"
+  desc "run-app-in-vm app_name","Runs an application in a VM."
+  def run_app_in_vm(app_name)
+
+    apk_name = /([\w\.]+).apk$/.match(app_name)[1]
+    puts "Running run_app_in_vm for application : #{apk_name}"
+
+    if options[:dedicated_vm]
+      manager = Vbmanager.new(vm_image:options[:vm_image_name])
+      #manager.import_ovf
+      Vbmanager.list_vms
+      manager.clone_vm
+      manager.configure_vm(accelerated:options[:accelerate3d])
+      manager.start_vm
+    else
+      manager = Vbmanager.new(vm_image:options[:vm_image_name],reuse:true)
+      #manager.create_snapshot #should already be created
+      manager.start_vm
+    end
+
+    adbrunner = Adbrunner.new(port:manager.port)
+    adbrunner.wait_for_boot
+
+    apprunner = Apprunner.new(adb:adbrunner)
+    apprunner.install_app app_name
+    apprunner.run_app(apk_name)
+    apprunner.monkey_app(apk_name, options[:monkey_events])
+
+    puts "Waiting for #{options[:execution_time]}"
+    sleep options[:execution_time]
+
+    apprunner.kill_app(apk_name)
+
+    if options[:dedicated_vm]
+      manager.stop_vm
+      manager.del_vm
+    else
+      manager.stop_vm
+      manager.load_snapshot
+    end
+  end
+
+  option :execution_time, type: :numeric, default: 60, desc: "Time to execute app"
+  option :monkey_events, type: :numeric, default: 500, desc: "Number of monkey events to execute"
+  desc "run_app_in_device DEVICE_ID APP","Runs an application in a physical device."
+  def run_app_in_device(device_id, app_name)
+    apk_name = /([\w\.]+).apk$/.match(app_name)[1]
+    puts "Running run_app_in_vm for application : #{apk_name}"
+
+    manager = Devicemanager.new(id:device_id)
+    adb = Adbrunner.new(id:device_id)
+    apprunner = Apprunner.new(adb:adb)
+
+    apprunner.install_app app_name
+    apprunner.run_app(apk_name)
+    apprunner.monkey_app(apk_name, options[:monkey_events])
+
+    puts "Waiting for #{options[:execution_time]}"
+    sleep options[:execution_time]
+
+    apprunner.kill_app(apk_name)
+  end
+
+  desc "run_apps_in_isolation APP_FOLDER","Runs the applications in the folder in an isolated manner"
+  option :execution_time, type: :numeric, default: 60, desc: "Time to execute app"
+  option :monkey_events, type: :numeric, default: 500, desc: "Number of monkey events to execute"
+  option :physical_device_ID, type: :string, default: nil, desc: "If it should be run in a physical device this field should be set with the device ID"
+  def run_apps_in_isolation(app_folder)
+
+    manager = nil
+    adb = nil
+    apprunner = nil
+    dedicated = false
+
+    if options[:physical_device_ID] == nil
+      array = Vbmanager.get_existing_pool_images
+
+      if array.size > 0
+        manager = Vbmanager.new(vm_image:options[:vm_image_name],reuse:true)
+      else
+        dedicated = true
+        manager = Vbmanager.new(vm_image:options[:vm_image_name])
+        manager.clone_vm
+        manager.configure_vm(accelerated:options[:accelerate3d])
+        manager.create_snapshot
+        manager.start_vm
+      end
+
+      adbrunner = Adbrunner.new(port:manager.port)
+      adbrunner.wait_for_boot
+      apprunner = Apprunner.new(adb:adbrunner)
+
+    else
+      manager = Devicemanager.new(id:options[:physical_device_ID])
+      adb = Adbrunner.new(id:options[:physical_device_ID])
+      apprunner = Apprunner.new(adb:adb)
+    end
+
+    Dir.glob("#{app_folder}/*.apk").each do |apk|
+
+      apk_name = /([\w\.]+).apk$/.match(app_name)[1]
+      puts "Running run_app_in_vm for application : #{apk_name}"
+
+      puts "Processing #{apk_name} in #{apk}..."
+
+      #Install and run app
+      apprunner.install_app app_name
+      apprunner.run_app(apk_name)
+      apprunner.monkey_app(apk_name, options[:monkey_events])
+
+      #puts "Waiting for #{options[:execution_time]}"
+      #sleep options[:execution_time]
+
+      #Clean VM/Device
+      apprunner.kill_app(apk_name)
+
+    end
+
+    #Revert VM state and stop VM
+    if options[:physical_device_ID] == nil
+      if dedicated
+        manager.stop_vm
+        manager.del_vm
+      else
+        manager.stop_vm
+        manager.load_snapshot
+      end
+    end
+
+
+  end
+
+  option :vm_image_name, type: :string, default: "AndroidX86"
+  option :number_of_vms, type: :numeric, default: 2
+  desc "allocate_vm_pool","Creates a pool of VMs. VMs are not launched, just created."
+  def allocate_vm_pool
+
+    array = Vbmanager.get_existing_pool_images
+    to_create = options[:number_of_vms] - array.size
+
+    if to_create <= 0
+      puts "Pool already contains #{array.size} VMs (requested VMS: #{options[:number_of_vms]})"
+      return
+    end
+
+    for i in 1..to_create
+      manager = Vbmanager.new(vm_image:options[:vm_image_name],is_pool:true)
+      #manager.import_ovf
+      manager.clone_vm
+      manager.configure_vm
+      manager.create_snapshot
+    end
+    Vbmanager.list_vms
+  end
+end
+
+#require 'droidrunner/apprunner'

data/lib/droidrunner/adbrunner.rb

@@ -0,0 +1,97 @@
+require 'thor'
+
+class Adbrunner #< Thor
+
+  def initialize(id:"localhost", port:nil)
+
+     @id = id
+     @port = port
+     if port != nil
+       @connect_id = "#{id}:#{port}"
+     else
+       raise "Attempt to create physical device adb without id!" if id == "localhost"
+       @connect_id = "#{id}"
+     end
+
+     puts "Initializing adb with #{@connect_id}"
+  end
+
+  #desc "kill","Kills the adb connection"
+  def kill(silent:false)
+      puts "Kill adb"
+      puts %x(adb kill-server)
+  end
+
+  #desc "connect","Connects adb to device"
+  def connect(silent:false)
+      puts "Connecting adb to #{@connect_id}" if !silent
+      res = %x(adb connect #{@connect_id})
+      puts res if !silent
+  end
+
+  #desc "install APP","Installs an application via adb"
+  def install(app)
+      puts "Installing #{app} adb to #{@connect_id}"
+      puts %x(adb -s #{@connect_id} install #{app})
+  end
+
+  #desc "shell CMD","Kills the adb connection"
+  def shell(cmd:,silent:false)
+    if !silent
+      puts "Executing shell command adb to #{@connect_id} -> #{cmd}"
+      ret= %x(adb -s #{@connect_id} shell #{cmd})
+      puts ret
+    else
+      ret = %x(adb -s #{@connect_id} shell #{cmd} 2>&1)
+    end
+
+    ret
+  end
+
+  def wait_for_boot
+    puts "Waiting for boot completion of #{@connect_id}..."
+    sl = true
+    while sl
+      connect(silent:true)
+      ret = shell(cmd:"getprop dev.bootcomplete", silent:true)
+
+      if ret.to_i == 1
+        sl = false
+        print "1..."
+      else
+        print "0..."
+      end
+
+      sleep 5
+    end
+    puts ""
+  end
+
+  def self.get_devices(silent:false)
+    array = Array.new
+    list = Adbrunner.devices(silent:true)
+    list.scan(/^([^\s]+)[\s]+[\w]+$/) { |id|
+      array.push(id[0])
+    }
+    puts array.inspect if !silent
+    array
+  end
+
+  def self.get_physical_devices(silent:false)
+    array = Adbrunner.get_devices
+    res = Array.new
+    array.each { |device|
+      next if device.include? ":"
+      res.push device
+    }
+    res
+  end
+
+  def self.devices(silent:false)
+    puts "Listing adb devices" if !silent
+    ret = %x(adb devices)
+    puts ret if !silent
+    ret
+  end
+
+end

data/lib/droidrunner/apprunner.rb

@@ -0,0 +1,44 @@
+require 'thor'
+
+class Apprunner #< Thor
+
+  def initialize(adb:nil, port:55551)
+    puts "Creating adb connection"
+    if adb == nil
+     @adbrunner = Adbrunner.new(port:port)
+     #@adbrunner.kill
+     @adbrunner.connect
+   else
+     @adbrunner = adb
+   end
+
+   Adbrunner.devices
+  end
+
+  #desc "install_app APPNAME","Installs an app in a VM"
+  def install_app(app)
+    puts "Installing app #{app}"
+    @adbrunner.install(app)
+  end
+
+  #desc "run_app APP_PACKAGE MAIN_ACTIVITY","Runs an app in a VM"
+  def run_app(app)
+      puts "Running app : #{app}"
+      #@adbrunner.shell(cmd:"am start -n #{app}/#{activity}")
+      #Running monkey with just one event is icon click (i.e. opening app)
+      @adbrunner.shell(cmd:"monkey -p #{app} -c android.intent.category.LAUNCHER 1")
+  end
+
+  def monkey_app(app,events)
+    puts "Running monkey #{events} events on #{app}"
+    @adbrunner.shell(cmd:"monkey -p #{app} -c android.intent.category.LAUNCHER -v #{events}")
+  end
+
+  #desc "kill_app APPNAME","Kills an app in a VM"
+  def kill_app(app)
+      puts "Killing app #{app}"
+      @adbrunner.shell(cmd:"am force-stop #{app}")
+      @adbrunner.shell(cmd:"pm clear #{app}")
+  end
+
+end

data/lib/droidrunner/devicemanager.rb

@@ -0,0 +1,50 @@
+
+class Devicemanager #< Thor
+
+  attr_accessor :device_id
+  @@registered_devices = Set.new
+  @@locked_devices = Array.new
+
+  def initialize(id:nil)
+
+    physical_devs = Adbrunner.get_physical_devices
+
+    if id == nil
+
+      #TODO: this is totally not process safe
+      available = @@registered_devices - @@locked_devices
+
+      raise "There were no physical devices registered" if available.size <= 0
+
+      available = available & physical_devs
+
+      raise "There were available registered devices but they were not connected!" if available.size <= 0
+
+      acquire_device(available[0])
+      @device_id = available[0]
+
+    else
+      available = [id] & physical_devs
+
+      raise "Device id was not connected!" if available.size <= 0
+
+      acquire_device(id)
+      @device_id = id
+    end
+
+    puts "Created a device manager for device id: #{@device_id}"
+  end
+
+  def register_device(id)
+    @@registered_devices.push id
+  end
+
+  def acquire_device(id)
+    @@locked_devices.push id #TODO: this will be in a sync db or something
+  end
+
+  def release_device(id)
+    @@locked_devices.delete id #TODO: this will be in a sync db or something
+  end
+
+end

data/lib/droidrunner/vbmanager.rb

@@ -0,0 +1,146 @@
+require 'thor'
+
+class Vbmanager #< Thor
+
+  attr_accessor :port
+  @@current_id=1
+  @@locked_machines = Array.new
+  @@starting_id = 5555
+
+  def initialize(vm_image:nil,is_pool:false,reuse:false)
+    @vm_image=vm_image
+    @is_pool = is_pool
+
+    puts "Locked machines : #{@@locked_machines}"
+    running = Vbmanager.get_running_pool_images
+    puts "Running VMS : #{running.inspect}"
+    vms = Vbmanager.get_existing_pool_images
+    puts "Registered VMS : #{vms.inspect}"
+    not_running = vms - running
+    not_running -= @@locked_machines
+    puts "Available VMS : #{not_running.inspect}"
+
+    if vms.size != 0
+      max = vms.max
+      @@current_id = max + 1 if max >= @@current_id
+    end
+
+    puts "Setted current VM id to #{@@current_id}..."
+
+    if !reuse
+     @id = @@current_id
+     @@current_id +=1
+
+     @vm_clone = "#{@vm_image}-#{@id}" if !is_pool
+     @vm_clone = "#{@vm_image}-pool#{@id}" if is_pool
+
+     @@locked_machines.push(@id)
+     @configured = false
+     @is_reused = false
+    else
+      if not_running.size == 0
+        raise "No available machines for reuse!!!"
+      end
+
+      @is_reused = true
+      @id = not_running[0]
+      @vm_clone = "#{vm_image}-pool#{@id}"
+      @@locked_machines.push(@id)
+      @configured = true
+    end
+
+    @last_snap = "#{@vm_clone}-snap"
+    @port = @@starting_id + @id
+
+    puts "Setted ID to #{@id}"
+    puts "Setted VM Clone name to #{@vm_clone}..."
+    puts "Setted port to #{@port}"
+
+  end
+
+  #desc "list_vms","Lists Virtual Box VMs"
+  def self.list_vms(silent:false)
+      puts "Listing vms" if !silent
+      ret = %x(VBoxManage list vms)
+      puts ret if !silent
+      ret
+  end
+
+  def self.list_running_vms(silent:false)
+    puts "Listing running vms" if !silent
+    ret = %x(vboxmanage list runningvms)
+    puts ret if !silent
+    ret
+  end
+
+  def self.get_running_pool_images
+    ids = Array.new
+    list = list_running_vms(silent:true)
+    list.scan(/#{@vm_image}-pool([\d]+)/) { |id|
+      ids.push(id.to_i)
+    }
+    ids
+  end
+
+  def self.get_existing_pool_images
+    ids = Array.new
+    list = list_vms(silent:true)
+    list.scan(/#{@vm_image}-pool([\d]+)/) { |id|
+      ids.push(id[0].to_i)
+    }
+    ids
+  end
+
+  #desc "import_ovf VMNAME","Imports a VM image"
+  def import_ovf
+    puts "Importing vm image: #{@vm_image}"
+    puts %x(VBoxManage import #{@vm_image})
+  end
+
+  def configure_vm(accelerated:false, memory:1024)
+    puts "Setting Network... NAT"
+    puts %x(VBoxManage modifyvm #{@vm_clone} --nic1 nat)
+    puts "Setting adb port forwarding...#{@port}"
+    puts %x(VBoxManage modifyvm #{@vm_clone} --natpf1 #{@vm_clone}-adb,tcp,*,#{@port},*,5555)
+    puts "Setting 3D Acceleration... #{accelerated}"
+    puts %x(VBoxManage modifyvm #{@vm_clone} --accelerate3d off) if !accelerated
+    puts "Setting Memory... #{memory}"
+    puts %x(VBoxManage modifyvm #{@vm_clone} --memory #{memory})
+    @configured = true
+  end
+
+  def create_snapshot
+    puts "WARNING: #{@vm_clone} was not configured!" if !@configured
+    puts "Creating a snapshot #{@last_snap} for machine #{@vm_clone}"
+    puts %x(VBoxManage snapshot #{@vm_clone} take #{@last_snap})
+  end
+
+  def load_snapshot
+    puts "Loading snapshot #{@last_snap} for machine #{@vm_clone}"
+    puts %x(VBoxManage snapshot #{@vm_clone} restore #{@last_snap})
+  end
+
+  def clone_vm
+      puts "Cloning VM #{@vm_image} to #{@vm_clone}..."
+      puts %x(VBoxManage clonevm --mode machine #{@vm_image} --name #{@vm_clone} --register)
+      puts "Unlocking machine : #{@vm_clone}" if !@is_reused && @is_pool
+      @@locked_machines.delete(@id) if !@is_reused && @is_pool
+  end
+
+  #desc "start_vm","Starts a VM"
+  def start_vm(headless:true)
+      puts "WARNING: #{@vm_clone} was not configured!" if !@configured
+      puts "Starting VM #{@vm_clone}"
+      puts %x(VBoxManage startvm #{@vm_clone} --type headless) if headless
+      puts %x(VBoxManage startvm #{@vm_clone}) if !headless
+  end
+
+  def stop_vm
+      puts %x(VBoxManage controlvm #{@vm_clone} poweroff soft)
+  end
+
+  def del_vm
+      puts %x(VBoxManage unregistervm #{@vm_clone} --delete)
+  end
+
+end

data/test/test_droidrunner.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+require 'droidrunner'
+
+class DroidrunnerTest < Test::Unit::TestCase
+  def test_adb
+    assert_nothing_raised( RuntimeError ) {
+      adb = Adbrunner.new("127.0.0.1")
+      adb.adb_kill
+      adb.adb_connect
+      adb.adb_install('test-app')
+      adb.adb_shell('cmd-test')
+    }
+  end
+
+  def test_apprunner
+    assert_nothing_raised( RuntimeError ) {
+      apprunner = Apprunner.new("127.0.0.1")
+      apprunner.install_app "test-app"
+      apprunner.run_app("test-app","test-activity")
+      apprunner.kill_app "test-app"
+    }
+  end
+
+  def test_vbmanager
+    #assert_equal "droidrunner mundo", Droidrunner.hi("spanish")
+  end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: droidspecter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mario Almeida
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-03 00:00:00.000000000 Z
+dependencies: []
+description: Droidspecter
+email: 4knahs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- bin/droidrunner
+- lib/droidrunner.rb
+- lib/droidrunner/adbrunner.rb
+- lib/droidrunner/apprunner.rb
+- lib/droidrunner/devicemanager.rb
+- lib/droidrunner/vbmanager.rb
+- test/test_droidrunner.rb
+homepage: http://rubygems.org/gems/droidrunner
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 3
+summary: Droidrunner!
+test_files:
+- test/test_droidrunner.rb
+has_rdoc: