hive-runner-android 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 791d7c48d21d1e3627d48e26c5533b9322e84fa3
-  data.tar.gz: 8d3b477541b6c21792b41bb9842df29826ebe24a
+  metadata.gz: 76719b13d1011b70fadf007b22fe7dd936319a47
+  data.tar.gz: 46f0e34cc3a6178c5d25ca9c5c63aed074fceb1c
 SHA512:
-  metadata.gz: 7efa0377366f1eede0880a902d00a7f7ca0737bfbe5010c7ed723597ee3457584b10749bb0f1916b3a2e8d96c76a79ffc47fefaae012c2e62023816bde90ff97
-  data.tar.gz: 756c0d99968a708b3e465327595b7dffc5e1ff270c6636061a2630b7eccab56ad4d0d1f6eb457832380c5d0442a8b9bb2d41007048d47863d1bcd5251bb8e33b
+  metadata.gz: 292ebf4003518d361c169fdfba25652b37c7a6b04f7bc53a98bd23e0ec317f5499add31c8cd1c1edbd0e6301627b7e97bf415e3121189c92d9538e287cececf4
+  data.tar.gz: 5b62ace7cb0c0a3bbb2f930f5db7e400ba56fed1c7cf3b014d3fdf019667dbe6f33ca5713b57ce97bf361ac106e10cc2f2706cd8ec8e7853b4611937461c417c

data/lib/hive/controller/android.rb

@@ -6,107 +6,105 @@ 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
+      def detect
+        self.detect_hive_mind
+        self.detect_devicedb
       end
 
-      def populate_queues(device)
-        queues = calculate_queue_names(device)
-
-        # Add the queue prefix if it has 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) }
+      # Register with Hive Mind (New)
+      def detect_hive_mind
+        devices = DeviceAPI::Android.devices
+        Hive.logger.debug('HM) No devices attached') if devices.empty?
 
-        values = {
-            name: device['name'],
-            hive_id: device['hive_id'],
-            feature_list: device['features'],
-            device_queue_ids: queue_ids
-        }
+        if not Hive.hive_mind.device_details.has_key? :error
+          # Selecting only android mobiles
+          connected_devices = Hive.hive_mind.device_details['connected_devices'].select{ |d| d['device_type'] == 'Mobile' && d['operating_system_name'] == 'android' }
 
-        Hive.devicedb('Device').edit(device['id'], values)
-      end
+          to_poll = []
+          attached_devices = []
+          connected_devices.each do |device|
+            Hive.logger.debug("HM) Device details: #{device.inspect}")
+            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("HM) Removing previously registered device - #{device}")
+              Hive.hive_mind.disconnect(device['id'])
+            else
+              # A previously registered device is attached, poll it
+              Hive.logger.debug("HM) Setting #{device} to be polled")
+              Hive.logger.info("HM) Stuff: #{registered_device.inspect}")
+              begin
+                attached_devices << self.create_device(device.merge('os_version' => registered_device[0].version))
+                to_poll << device['id']
+              rescue DeviceAPI::DeviceNotFound => e
+                Hive.logger.warn("HM) Device disconnected before registration (serial: #{device.serial})")
+              rescue => e
+                Hive.logger.warn("HM) Error with connected device: #{e.message}")
+              end
 
-      def find_or_create_queue(name)
-        queue = Hive.devicedb('Queue').find_by_name(name)
+              devices = devices - registered_device
+            end
+          end
 
-        return queue.first['id'] unless queue.empty? || queue.is_a?(Hash)
+          # Poll already registered devices
+          Hive.logger.debug("HM) Polling: #{to_poll}")
+          Hive.hive_mind.poll(*to_poll)
+
+          # Register new devices
+          devices.select{|a| a.status != :unauthorized}.each do |device|
+            begin
+              dev = Hive.hive_mind.register(
+                  hostname: device.model,
+                  serial: device.serial,
+                  macs: [device.wifi_mac_address],
+                  ips: [device.ip_address],
+                  brand: device.manufacturer.capitalize,
+                  model: device.model,
+                  device_type: 'Mobile',
+                  imei: device.imei,
+                  operating_system_name: 'android',
+                  operating_system_version: device.version
+              )
+              Hive.hive_mind.connect(dev['id'])
+              Hive.logger.info("HM) Device registered: #{dev}")
+            rescue DeviceAPI::DeviceNotFound => e
+              Hive.logger.warn("HM) Device disconnected before registration (serial: #{device.serial})")
+            rescue => e
+              Hive.logger.warn("HM) Error with connected device: #{e.message}")
+            end
+          end
 
-        queue = create_queue(name, "#{name} queue created by Hive Runner")
-        queue['id'] unless queue.empty?
-      end
+        else
+          Hive.logger.info('HM) No Hive Mind connection')
+          # Hive Mind isn't available, use DeviceAPI instead
+          device_info = devices.select { |a| a.status != :unauthorized }.map do |device|
+            {
+              'id' =>  device.serial,
+              'serial' => device.serial,
+              'status' => 'idle',
+              'model' => device.model,
+              'brand' => device.manufacturer,
+              'os_version' => device.version
+            }
+          end
 
-      def create_queue(name, description)
-        queue_attributes = {
-            name: name,
-            description: description
-        }
+          attached_devices = device_info.collect do |physical_device|
+            self.create_device(physical_device)
+          end
+        end
 
-        Hive.devicedb('Queue').register(device_queue: queue_attributes )
+        Hive.logger.info(attached_devices)
+        attached_devices
       end
 
-      def detect
+      # Register with DeviceDB (Old)
+      def detect_devicedb
         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")
-
-        devices.each do |device|
-          begin
-            Hive.hive_mind.register(
-                hostname: device.model,
-                serial: device.serial,
-                macs: [device.wifi_mac_address],
-                ips: [device.ip_address],
-                brand: device.manufacturer.capitalize,
-                model: device.model,
-                device_type: 'Mobile',
-                imei: device.imei,
-                hive_id: Hive.id
-            )
-          rescue DeviceAPI::DeviceNotFound
-            Hive.logger.info("Device '#{device.serial}' disconnected during registration")
-            devices.delete(device)
-          rescue DeviceAPI::UnauthorizedDevice
-            Hive.logger.info("Device '#{device.serial}' is unauthorized")
-            devices.delete(device)
-          rescue => e
-            Hive.logger.warn("Error with connected device: #{e.message}")
-            devices.delete(device)
-          end
-        end
+        attached_devices = []
 
         if hive_details.key?('devices')
           # Update the 'cached' results from DeviceDB
@@ -130,10 +128,21 @@ module Hive
               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
+              begin
+                attached_devices <<
+                    self.create_device(device.merge(
+                      'os_version' => registered_device[0].version,
+                      'model' => device['device_model'],
+                      'brand' => device['device_brand'],
+                      'queues' => device['device_queues'].map{ |d| d['name'] },
+                      'queue_prefix' => @config['queue_prefix']
+                    ))
+              rescue DeviceAPI::DeviceNotFound
+                Hive.logger.info("Device '#{device.serial}' disconnected during registration")
+              rescue => e
+                Hive.logger.warn("Error with connected device: #{e.message}")
+              end
             end
           end
 
@@ -142,20 +151,26 @@ module Hive
           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 } } ]}]}
+
+          device_info = devices.select { |a| a.status != :unauthorized }.map do |device|
+            {
+              'id' =>  device.serial,
+              'serial' => device.serial,
+              'status' => 'idle',
+              'model' => device.model,
+              'brand' => device.manufacturer,
+              'os_version' => device.version,
+              'queue_prefix' => @config['queue_prefix']
+            }
           end
 
-          device_info.collect do |physical_device|
+          attached_devices = device_info.collect do |physical_device|
             self.create_device(physical_device)
           end
         end
+        attached_devices
       end
 
       def register_new_device(device)

data/lib/hive/device/android.rb

@@ -3,10 +3,56 @@ require 'hive/device'
 module Hive
   class Device
     class Android < Device
+      attr_accessor :model, :brand, :os_version
+
       def initialize(config)
         @identity = config['id']
+        @queue_prefix = config['queue_prefix'].to_s == '' ? '' : "#{config['queue_prefix']}-"
+        @model = config['model'].downcase.gsub(/\s/, '_')
+        @brand = config['brand'].downcase.gsub(/\s/, '_')
+        @os_version = config['os_version']
+
+        Hive.logger.info("Config: #{config.inspect}")
+        new_queues = calculate_queue_names
+        new_queues = new_queues | config['queues'] if config.has_key?('queues')
+
+        devicedb_ids = new_queues.map { |queue| find_or_create_queue(queue) }
+        Hive.devicedb('Device').edit(@identity, { device_queue_ids: devicedb_ids })
+        config['queues'] = new_queues
         super
       end
+
+      # Uses either DeviceAPI or DeviceDB to generate queue names for a device
+      def calculate_queue_names
+Hive.logger.info("QUEUE PREFIX; #{@queue_prefix}")
+        [
+          "#{@queue_prefix}#{self.model}",
+          "#{@queue_prefix}#{self.brand}",
+          "#{@queue_prefix}android",
+          "#{@queue_prefix}android-#{self.os_version}",
+          "#{@queue_prefix}android-#{self.os_version}-#{self.model}"
+        ]
+      end
+
+      private
+
+      def find_or_create_queue(name)
+        queue = Hive.devicedb('Queue').find_by_name(name)
+
+        return queue.first['id'] unless queue.empty? || queue.is_a?(Hash)
+
+        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
     end
   end
-end
+end

data/lib/hive/worker/android.rb

@@ -82,6 +82,7 @@ module Hive
       end
 
       def device_status
+        # TODO Get from Hive Mind
         details = Hive.devicedb('Device').find(@options['id'])
         if details.key?('status')
           @state = details['status']
@@ -91,6 +92,7 @@ module Hive
       end
 
       def set_device_status(status)
+        # TODO Report to Hive Mind
         @state = status
         begin
           details = Hive.devicedb('Device').poll(@options['id'], status)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hive-runner-android
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Jon Wilson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-09 00:00:00.000000000 Z
+date: 2016-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: device_api-android
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.5
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
@@ -87,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.0
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Hive Runner Android