hive-runner-android 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8df609a1edec60819bf8372dd0519f7851e7105f
+  data.tar.gz: f816df9c708723cb1515f205add30d59769a6934
+SHA512:
+  metadata.gz: d458e4ce5f50c4df97b8618c5ba97f95a3df6b36f35bf032868ac56c1d843a8be483080408f7b7fd2dc9eb1cc805356969adefeb9642f72d3ad1d6b23acfdec3
+  data.tar.gz: aef6e7d5bafde000682b901372ab897e53b57adc10810950ff02f3e9763027fcc286ae3d19f23ee4bc052a59bcb9bd38de5d2d5e28f67620cf20d133acd9e1ba

data/README.md

@@ -0,0 +1,33 @@
+# hive-runner-android
+Android module for Hive Runner
+
+## Quick start
+Install the hive-runner gem and set up your hive:
+
+    gem install hive-runner
+    hive_setup my_hive
+
+When you are asked whether you want to add a module, press 1 and enter `android` as the module name. You will then be able to select the latest version from either Github or Rubygems.
+
+Follow the configuration instructions and, in particular, ensure that the
+`HIVE_CONFIG` variable is set.
+
+Start the Hive daemon:
+
+    hived start
+
+Determine the status of the Hive:
+
+    hived status
+
+Stop the Hive:
+
+    hived stop
+
+## Configuration file
+
+Example config file:
+
+      android:
+       name_stub: ANDROID_WORKER
+       port_range_size: 10

data/lib/hive/controller/android.rb

@@ -0,0 +1,179 @@
+require 'hive/controller'
+require 'hive/worker/android'
+require 'device_api/android'
+
+module Hive
+  class Controller
+    class Android < Controller
+
+      # Uses either DeviceAPI or DeviceDB to generate queue names for a device
+      def calculate_queue_names(device)
+        if device.is_a? DeviceAPI::Android::Device
+          queues = [
+              device.model,
+              device.manufacturer,
+              'android',
+              "android-#{device.version}",
+              "android-#{device.version}-#{device.model}"
+          ]
+        else
+
+          queues = [
+              device['device_model'],
+              device['device_brand'],
+              device['os'],
+              "#{device['os']}-#{device['os_version']}",
+              "#{device['os']}-#{device['os_version']}-#{device['device_model']}"
+          ]
+
+          queues << device["features"] unless device["features"].empty?
+
+          queues.flatten
+        end
+        queues
+      end
+
+      def populate_queues(device)
+        queues = calculate_queue_names(device)
+
+        # Add the queue prefix if it hase been setup in the config
+        queues = queues.map { |a| "#{@config['queue_prefix']}-#{a}"} if @config['queue_prefix']
+
+        devicedb_queues = device['device_queues'].map { |d| d['name'] }
+        # Check to see if the queues have already been registered with this device
+        missing_queues = (queues - devicedb_queues) + (devicedb_queues - queues)
+        return if missing_queues.empty?
+
+        queues << missing_queues
+
+        queue_ids = queues.flatten.uniq.map { |queue| find_or_create_queue(queue) }
+
+        values = {
+            name: device['name'],
+            hive_id: device['hive_id'],
+            feature_list: device['features'],
+            device_queue_ids: queue_ids
+        }
+
+        Hive.devicedb('Device').edit(device['id'], values)
+      end
+
+      def find_or_create_queue(name)
+        queue = Hive.devicedb('Queue').find_by_name(name)
+        return queue.first['id'] unless queue.empty?
+
+        queue = create_queue(name, "#{name} queue created by Hive Runner")
+        queue['id'] unless queue.empty?
+      end
+
+      def create_queue(name, description)
+        queue_attributes = {
+            name: name,
+            description: description
+        }
+
+        Hive.devicedb('Queue').register(device_queue: queue_attributes )
+      end
+
+      def detect
+        devices = DeviceAPI::Android.devices
+        Hive.logger.debug('No devices attached') if devices.empty?
+        Hive.logger.debug("#{Time.now} Retrieving hive details")
+        hive_details = Hive.devicedb('Hive').find(Hive.id)
+        Hive.logger.debug("#{Time.now} Finished fetching hive details")
+
+        if hive_details.key?('devices')
+          # Update the 'cached' results from DeviceDB
+          @hive_details = hive_details
+        else
+          # DeviceDB isn't available - use the cached version
+          hive_details = @hive_details
+        end
+
+        if hive_details.is_a? Hash
+          # DeviceDB information is available, use it
+          hive_details['devices'].select {|a| a['os'] == 'android'}.each do |device|
+            registered_device = devices.select { |a| a.serial == device['serial'] && a.status != :unauthorized}
+            if registered_device.empty?
+              # A previously registered device isn't attached
+              Hive.logger.debug("Removing previously registered device - #{device}")
+              Hive.devicedb('Device').hive_disconnect(device['id'])
+            else
+              # A previously registered device is attached, poll it
+              Hive.logger.debug("#{Time.now} Polling attached device - #{device}")
+              Hive.devicedb('Device').poll(device['id'])
+              Hive.logger.debug("#{Time.now} Finished polling device")
+
+              # Make sure that this device has all the queues it should have
+              populate_queues(device)
+
+              devices = devices - registered_device
+            end
+          end
+
+          devices.each do |device|
+            register_new_device(device)
+          end
+
+          display_devices(hive_details)
+
+          hive_details['devices'].select {|a| a['os'] == 'android'}.collect do |hive_device|
+            self.create_device(hive_device)
+          end
+        else
+          # DeviceDB isn't available, use DeviceAPI instead
+          device_info = devices.map do |device|
+            {'id' =>  device.serial, 'serial' => device.serial, status: 'idle', devices: [{ device_queues: [ calculate_queue_names(device).map { |q| { name: q } } ]}]}
+          end
+
+          device_info.collect do |physical_device|
+            self.create_device(physical_device)
+          end
+        end
+      end
+
+      def register_new_device(device)
+        begin
+          Hive.logger.debug("Adding new Android device: #{device.model}")
+
+          attributes = {
+              os: 'android',
+              os_version: device.version,
+              serial: device.serial,
+              device_type: 'mobile',
+              device_model: device.model,
+              device_brand: device.manufacturer,
+              device_range: device.range,
+              hive: Hive.id
+          }
+        rescue DeviceAPI::Android::ADBCommandError
+          # If a device has been disconnected while we're trying to add it, the device_api
+          # gem will throw an error
+          Hive.logger.debug('Device disconnected while attempting to add')
+        end
+
+        registration = Hive.devicedb('Device').register(attributes)
+        Hive.devicedb('Device').hive_connect(registration['id'], Hive.id)
+      end
+
+      def display_devices(hive_details)
+        rows = []
+        if hive_details.key?('devices')
+          unless hive_details['devices'].empty?
+            rows = hive_details['devices'].map do |device|
+              [
+                  "#{device['device_brand']} #{device['device_model']}",
+                  device['serial'],
+                  (device['device_queues'].map { |queue| queue['name']}).join("\n"),
+                  device['status']
+              ]
+            end
+          end
+        end
+        table = Terminal::Table.new :headings => ['Device', 'Serial', 'Queue Name', 'Status'], :rows => rows
+
+        Hive.logger.info(table)
+      end
+    end
+  end
+end

data/lib/hive/device/android.rb

@@ -0,0 +1,12 @@
+require 'hive/device'
+
+module Hive
+  class Device
+    class Android < Device
+      def initialize(config)
+        @identity = config['id']
+        super
+      end
+    end
+  end
+end

data/lib/hive/diagnostic/android/battery.rb

@@ -0,0 +1,38 @@
+require 'hive/diagnostic'
+module Hive
+  class Diagnostic
+    class Android
+    class Battery < Diagnostic
+
+      def battery
+        self.device_api.battery_info
+      end
+      
+      def diagnose
+        result = nil
+        battery_info = battery
+        begin
+          if config != nil && config.keys.count != 0  
+            temperature = battery_info['temperature']
+            if temperature.to_i < config['temperature'].to_i
+              result = self.pass("Temperature: #{temperature}\n Battery status: OK", "battery")
+            else
+              result = self.fail("Battery temperature above threshold. Temperature: #{temperature} ", "battery")
+            end
+          else
+            result = self.pass("No parameter specified for battery", "battery")
+          end
+        rescue
+          Hive.logger.error("Invalid Battery Parameter")
+          raise InvalidParameterError.new("Invalid Parameter for battery") if !result
+        end
+        result
+      end
+
+      def repair(result)
+        result = self.fail("Battery temperature above threshold.", "battery")
+      end
+    end
+    end
+  end
+end

data/lib/hive/diagnostic/android/memory.rb

@@ -0,0 +1,47 @@
+require 'hive/diagnostic'
+module Hive
+  class Diagnostic
+    class Android
+      class Memory < Diagnostic
+
+        def memory
+          @memory = self.device_api.memory unless @memory
+          mem = @memory.mem_info
+          return {:free => mem.free.split(' ')[0], 
+                  :total => mem.total.split(' ')[0], 
+                  :used => mem.used.split(' ')[0], }
+        end
+
+        def diagnose
+          result = nil
+          operator = {:free => :>=, :used => :<= , :total => :==}
+          memory_status = memory
+          if config != nil && config.keys.count != 0
+            config.each do |key, value|
+              begin
+                if memory_status[:"#{key}"].to_i.send(operator[:"#{key}"], value.to_i) 
+                  result = self.pass("#{key.capitalize} Memory (#{memory_status[:"#{key}"]}) #{operator[:"#{key}"]} #{value}", "memory" )
+                else
+                  result = self.fail("Error: #{key.capitalize} Memory (#{memory_status[:"#{key}"]}) is not #{operator[:"#{key}"]} #{value}", "memory")
+                  break
+                end
+              rescue
+                Hive.logger.error("Invalid Memory Parameter")
+                raise InvalidParameterError.new("Invalid Parameter for memory") if !result
+              end
+            end 
+          else 
+            result = self.pass("No parameter specified", "memory")
+          end
+        result
+        end
+
+        def repair(result)
+          # Add repair for memory
+          self.fail("Cannot repair memory", "memory")
+        end
+
+      end
+    end
+  end
+end

data/lib/hive/diagnostic/android/uptime.rb

@@ -0,0 +1,33 @@
+require 'hive/diagnostic'
+module Hive
+  class Diagnostic
+    class Android
+      class Uptime < Diagnostic
+        
+        def diagnose
+          if config.has_key?(:reboot_timeout)
+            uptime = self.device_api.uptime 
+            if  uptime < config[:reboot_timeout]
+              self.pass("Time for next reboot: #{config[:reboot_timeout] - uptime}s", "Reboot")
+            else
+              self.fail("Reboot required", "Reboot")
+            end
+          else
+            self.pass("Not configured for reboot", "Reboot")
+          end
+        end
+        
+        def repair(result)
+          Hive.logger.info("Rebooting the device")
+          begin  
+            self.device_api.reboot
+            sleep 30
+          rescue
+            Hive.logger.error("Device not found")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/hive/diagnostic/android/wifi.rb

@@ -0,0 +1,58 @@
+require 'hive/diagnostic'
+module Hive
+  class Diagnostic
+    class Android
+    class Wifi < Diagnostic
+
+      def wifi
+        wifi_details = self.device_api.wifi_status
+        return {:status => wifi_details[:status].scan(/^[^\/]*/)[0], :access_point => wifi_details[:access_point]}
+      end
+
+      def diagnose
+        result = nil
+        wifi_status = wifi
+
+        if wifi_status[:access_point].capitalize == "Xxxx"
+          result = self.pass("Kindle returns wifi 'xxxx'", "wifi")
+          return result
+        end
+
+        config.each do |key, value|
+          if config != nil && config.keys.count != 0
+            begin
+              if wifi_status[:"#{key}"].capitalize == value.capitalize 
+                result = self.pass("#{key.capitalize} : #{wifi_status[:"#{key}"]}", "wifi" )
+              else
+                result = self.fail(" Error: #{key.capitalize} : #{wifi_status[:"#{key}"]} ", "wifi")
+                break
+              end
+            rescue 
+              Hive.logger.error("Invalid Parameter for Wifi #{key}")
+              raise InvalidParameter.new("Invalid Wifi Parameter for Wifi: #{key}") if !result
+            end
+          else
+            result = self.pass("No parameter specified", "wifi")
+          end
+        end
+        result
+      end 
+
+      def repair(result)
+        Hive.logger.info("Trying to repair wifi")
+        options = {:apk => '/path/to/apk/to/toggle/wifi', :package => '/pkg/name/ex: com.wifi.togglewifi'} 
+        begin
+          self.device_api.install(options[:apk])
+          self.device_api.start_intent("-n com.wifi.togglewifi/.MainActivity -e wifi true")
+          sleep 5 
+          self.device_api.uninstall(options[:package])
+        rescue
+          Hive.logger.error("Unable to fix wifi issue")
+        end
+        diagnose
+      end
+  
+    end
+    end
+  end
+end

data/lib/hive/messages/android_job.rb

@@ -0,0 +1,11 @@
+require 'hive/messages'
+
+module Hive
+  module Messages
+    class AndroidJob < Hive::Messages::Job
+      def build
+        self.target.symbolize_keys[:build]
+      end
+    end
+  end
+end

data/lib/hive/worker/android.rb

@@ -0,0 +1,102 @@
+require 'hive/worker'
+require 'hive/messages/android_job'
+
+module Hive
+  class PortReserver
+    attr_accessor :ports
+    def initialize
+      self.ports = {}
+    end
+
+    def reserve(queue_name)
+      self.ports[queue_name] = yield
+      self.ports[queue_name]
+    end
+  end
+
+  class Worker
+    class Android < Worker
+
+      attr_accessor :device
+
+      def initialize(device)
+        @worker_ports = PortReserver.new
+        begin
+          device.merge!({"device_api" => DeviceAPI::Android.device(device['serial'])})
+        rescue DeviceAPI::Android::ADBCommandError
+          Hive.logger.info("Device disconnected during worker initialization")
+        end
+        set_device_status('idle')
+        self.device = device
+        super(device)
+      end
+
+      def adb_port
+        # Assign adb port for this worker
+        return @adb_port unless @adb_port.nil?
+        @adb_port = @port_allocator.allocate_port
+      end
+
+      def pre_script(job, file_system, script)
+        set_device_status('busy')
+        script.set_env "TEST_SERVER_PORT",    adb_port
+
+        # TODO: Allow the scheduler to specify the ports to use
+        script.set_env "CHARLES_PROXY_PORT",  @worker_ports.reserve(queue_name: 'Charles') { @port_allocator.allocate_port }
+        script.set_env "APPIUM_PORT",         @worker_ports.reserve(queue_name: 'Appium') { @port_allocator.allocate_port }
+        script.set_env "BOOTSTRAP_PORT",      @worker_ports.reserve(queue_name: 'Bootstrap') { @port_allocator.allocate_port }
+        script.set_env "CHROMEDRIVER_PORT",   @worker_ports.reserve(queue_name: 'Chromedriver') { @port_allocator.allocate_port }
+
+        script.set_env 'ADB_DEVICE_ARG', self.device['serial']
+
+        FileUtils.mkdir(file_system.home_path + '/build')
+        apk_path = file_system.home_path + '/build/' + 'build.apk'
+
+        script.set_env "APK_PATH", apk_path
+        if job.build
+          file_system.fetch_build(job.build, apk_path)
+          DeviceAPI::Android::Signing.sign_apk({apk: apk_path, resign: true})
+        end
+
+        DeviceAPI::Android.device(device['serial']).unlock
+
+        "#{self.device['serial']} #{@worker_ports.ports['Appium']} #{apk_path} #{file_system.results_path}"
+      end
+
+      def job_message_klass
+        Hive::Messages::AndroidJob
+      end
+
+      def post_script(job, file_system, script)
+        @log.info('Post script')
+        @worker_ports.ports.each do |name, port|
+          @port_allocator.release_port(port)
+        end
+        set_device_status('idle')
+      end
+
+      def device_status
+        details = Hive.devicedb('Device').find(@options['id'])
+        if details.key?('status')
+          @state = details['status']
+        else
+          @state
+        end
+      end
+
+      def set_device_status(status)
+        @state = status
+        begin
+          details = Hive.devicedb('Device').poll(@options['id'], status)
+          if details.key?('status')
+            details['status']
+          else
+            @state
+          end
+        rescue
+          @state
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: hive-runner-android
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Jon Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: device_api-android
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hive-runner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: The Android controller module for Hive Runner
+email: jon.wilson01@bbc.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/hive/controller/android.rb
+- lib/hive/device/android.rb
+- lib/hive/diagnostic/android/battery.rb
+- lib/hive/diagnostic/android/memory.rb
+- lib/hive/diagnostic/android/uptime.rb
+- lib/hive/diagnostic/android/wifi.rb
+- lib/hive/messages/android_job.rb
+- lib/hive/worker/android.rb
+homepage: https://github.com/bbc/hive-runner-android
+licenses:
+- MIT
+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.8
+signing_key: 
+specification_version: 4
+summary: Hive Runner Android
+test_files: []