hive-runner-ios 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce087ae313abd13cd813dbe4daeb1ea5625204fd
-  data.tar.gz: b47a160b3ffd69983f161f698b6489055f8f235f
+  metadata.gz: 724ac50af05ee7cdf94198938276fa1eb6374c31
+  data.tar.gz: 8f897659dc07f39f4e071e115c0e7617c06a7d63
 SHA512:
-  metadata.gz: 5d05cd92afb44b5705ce03eff687ece524d76af0f0849e9f1fbda7816d947d2083d8c35fe5268ae877675bb4d4f558eff226dc5e34fbaaf23c301a8b63606906
-  data.tar.gz: c47b32076c5e5593f0763cec1bddefcc37fb6a49ec94ec15489b9b017fd195f981060f210d5289a1ca11ba4565210e46b07badaf55cf64cefea5f0fcdbc2eef7
+  metadata.gz: 5b20456eec211381c47d40d46a737c237ead2d3100f49335bc91ba94de5d0891a0d55368d9b501ad0ad90a21511b1ea5929028c572d1c6659c8e8e6a3fa5e646
+  data.tar.gz: e43af665ee189763161e30db5b9ee5f31b15e640622edf7da50d9f53473d0b4a6dc743b9c3ad15b26776b66ab75d5dc61182c482194cfad5f655a5571b25517b

data/lib/hive/controller/ios.rb

@@ -6,97 +6,157 @@ module Hive
   class Controller
     class Ios < Controller
 
-      def detect
-        Hive.logger.debug("#{Time.now} Polling hive: #{Hive.id}")
-        Hive.devicedb('Hive').poll(Hive.id)
-        Hive.logger.debug("#{Time.now} Finished polling hive: #{Hive.id}")
+      def register_with_devicedb
         devices = DeviceAPI::IOS.devices
+        Hive.logger.debug('DDB: No devices attached') if devices.empty?
 
-        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 retrieving hive details")
 
-        unless hive_details.key?('devices')
-          Hive.logger.debug('Could not connect to DeviceDB at this time')
-          return []
+        attached_devices = []
+
+        if hive_details.key?('devices')
+          @hive_details = hive_details
+        else
+          hive_details = @hive_details
         end
 
-        unless hive_details['devices'].empty?
-          hive_details['devices'].select {|a| a['os'] == 'ios'}.each do |device|
-            registered_device = devices.select { |a| a.serial == device['serial'] }
+        if hive_details.is_a? Hash
+          hive_details['devices'].select { |a| a['os'] == 'ios'}.each do |device|
+            registered_device = devices.select { |a| a.serial == device['serial'] && a.trusted? }
             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 - #{device}")
 
-              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'],
+                        'device_range' => registered_device[0].device_class,
+                        'queues' => device['device_queues'].map{ |d| d['name'] },
+                        'queue_prefix' => @config['queue_prefix']
+                                       ))
+              rescue => e
+                Hive.logger.warn("Error with connected device: #{e.message}")
+              end
             end
           end
-        end
-
-        display_untrusted(devices)
-        display_devices
-
-        if hive_details.key?('devices')
-          hive_details['devices'].select {|a| a['os'] == 'ios'}.collect do |device|
-            object = Object
-            @device_class.split('::').each { |sub| object = object.const_get(sub) }
-            object.new(@config.merge(device))
+          devices.select {|a| a.trusted? }.each do |device|
+            register_new_device(device)
           end
         else
-          []
+          # DeviceDB isn't available, use DeviceAPI instead
+          device_info = devices.select { |a| a.trusted? }.map do |device|
+            {
+                'id' => device.serial,
+                'serial' => device.serial,
+                'status' => 'idle',
+                'model' => device.model,
+                'brand' => 'Apple',
+                'os_version' => device.version,
+                'queue_prefix' => @config['queue_prefix']
+            }
+          end
+
+          attached_devices = device_info.collect do |physical_device|
+            self.create_device(physical_device)
+          end
         end
+        attached_devices
       end
 
-      def display_untrusted(devices)
-        untrusted_devices = []
-        # We will now have a list of devices that haven't previously been added
-        devices.each do |device|
-          begin
-            if !device.trusted?
-              untrusted_devices << device.serial
-              next
+      def register_with_hivemind
+        devices = DeviceAPI::IOS.devices
+        Hive.logger.debug('HM: No devices attached') if devices.empty?
+
+        if not Hive.hive_mind.device_details.has_key? :error
+          connected_devices = Hive.hive_mind.device_details['connected_devices'].select{ |d| d['device_type'] == 'Mobile' && d['operating_system_name'] == 'ios' }
+
+          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.trusted? }
+            if registered_device.empty?
+              Hive.logger.debug("HM: Removing previously registered device - #{device}")
+              Hive.hive_mind.disconnect(device['id'])
+            else
+              Hive.logger.debug("HM: Device #{device} to be polled")
+              begin
+                attached_devices << self.created_device(device.merge('os_version' => registered_device[0].version))
+                to_poll << device['id']
+              rescue => e
+                Hive.logger.warn("HM: Error with connected device: #{e.message}")
+              end
+
+              devices = devices - registered_device
             end
+          end
 
-            register_new_device(device)
+          Hive.logger.debug("HM: Polling - #{to_poll}")
+          Hive.hive_mind.poll(*to_poll)
+
+          devices.select{|a| a.trusted? }.each do |device|
+            begin
+              dev = Hive.hive_mind.register(
+                  hostname: device.model,
+                  serial: device.serial,
+                  macs: [device.wifi_mac_address],
+                  brand: 'Apple',
+                  model: device.model,
+                  device_type: 'Mobile',
+                  imei: device.imei,
+                  operating_system_name: 'ios',
+                  operating_system_version: device.version
+              )
+              Hive.hive_mind.connect(dev['id'])
+              Hive.logger.info("HM: Device registered: #{dev}")
+            rescue => e
+              Hive.logger.warn("HM: Error with connected device - #{e.message}")
+            end
+          end
+        else
+          Hive.logger.info('HM: No Hive Mind connection')
+          device_info = devices.select{|a| a.trusted? }.map do |device|
+            {
+                'id' => device.serial,
+                'serial' => device.serial,
+                'status' => 'idle',
+                'model' => device.model,
+                'brand' => 'Apple',
+                'os_version' => device.version,
+                'queue_prefix' => @config['queue_prefix']
+            }
           end
-        end
 
-        if !untrusted_devices.empty?
-          puts Terminal::Table.new headings: ['Untrusted Devices'], rows: [untrusted_devices]
+          attached_devices = device_info.collect do |physical_device|
+            self.create_device(physical_device)
+          end
         end
+
+        Hive.logger.info(attached_devices)
+        attached_devices
       end
 
-      def display_devices
-        rows = []
+      def detect
+        register_with_devicedb
+        register_with_hivemind
+      end
 
-        hive_details = Hive.devicedb('Hive').find(Hive.id)
-        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
+      def display_untrusted
+        devices = DeviceAPI::IOS.devices
+        untrusted_devices = devices.select { |a| !a.trusted? }
 
-        puts(table)
+        return if untrusted_devices.empty?
+        puts Terminal::Table.new headings: ['Untrusted devices'], rows: [untrusted_devices]
       end
 
       def register_new_device(device)
-        Hive.logger.debug("Found iOS device: #{device.model}")
+        Hive.logger.debug("Adding new iOS device: #{device.model}")
 
         attributes = {
             os:           'ios',
@@ -135,37 +195,8 @@ module Hive
         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?
 
-        create_queue(name, "#{name} queue created by Hive Runner")['id']
-      end
-
-      def create_queue(name, description)
-        queue_attributes = {
-            name: name,
-            description: description
-        }
-
-        Hive.devicedb('Queue').register(device_queue: queue_attributes )
-      end
-
-      def calculate_queue_names(device)
-
-        queues = [
-            device['device_model'],
-            device['os'],
-            "#{device['os']}-#{device['os_version']}",
-            "#{device['os']}-#{device['os_version']}-#{device['device_model']}",
-            device['device_type'],
-            "#{device['os']}-#{device['device_type']}"
-        ]
-
-        queues << device["features"] unless device["features"].empty?
-
-        queues.flatten
-      end
     end
   end
-end
+end
+

data/lib/hive/device/ios.rb

@@ -3,10 +3,54 @@ require 'hive/device'
 module Hive
   class Device
     class Ios < Device
+      attr_accessor :model, :os_version, :device_type
+
       def initialize(config)
         @identity = config['id']
+        @queue_prefix = config['queue_prefix'].to_s == '' ? '' : "#{config['queue_prefix']}-"
+        @model = config['model'].downcase.gsub(/\s/, '_')
+        @device_range = config['device_range'].downcase
+        @os_version = config['os_version']
+
+        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
+
+      def calculate_queue_names
+        [
+            "#{@queue_prefix}#{self.model}",
+            "#{@queue_prefix}ios",
+            "#{@queue_prefix}ios-#{self.os_version}",
+            "#{@queue_prefix}ios-#{self.os_version}-#{self.model}",
+            "#{@queue_prefix}#{@device_range}",
+            "#{@queue_prefix}#{@device_range}-#{self.os_version}"
+        ]
+      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

data/lib/hive/worker/ios.rb

@@ -66,9 +66,9 @@ module Hive
           app_path = file_system.home_path + '/build/' + 'build.ipa'
 
           file_system.fetch_build(job.build, app_path)
-          entitlements = DeviceAPI::IOS::Signing.enable_get_tasks(app_path)
-          DeviceAPI::IOS::Signing.sign_app(@options['signing_identity'], entitlements: entitlements, app: app_path)
-          app_info = DeviceAPI::IOS::Plistutil.get_bundle_id_from_app(app_path)
+          entitlements = FruityBuilder::Signing.enable_get_tasks(app_path)
+          FruityBuilder::Signing.sign_app(@options['signing_identity'], entitlements: entitlements, app: app_path)
+          app_info = FruityBuilder::Plistutil.get_bundle_id_from_app(app_path)
           app_bundle = app_info['CFBundleIdentifier']
           device.install(app_path)
           script.set_env 'BUNDLE_ID', app_bundle

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: hive-runner-ios
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Jon Wilson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-10 00:00:00.000000000 Z
+date: 2016-02-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: hive-runner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
 - !ruby/object:Gem::Dependency
   name: device_api-ios
   requirement: !ruby/object:Gem::Requirement