fastlane-plugin-automated_test_emulator_run_mik 1.6.14 → 1.6.15.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5050c5e30d72adaa38cf2a5044c7afd6eb2996fa
-  data.tar.gz: 5584d1891080d00ad34f183b157d16d1a9c1691e
+  metadata.gz: 3e9cccc5342dd54f5f33b38a34e940407f4c6643
+  data.tar.gz: c2fa469dea9201edcdbcfd5ae8b5293d9a78401d
 SHA512:
-  metadata.gz: 186299efc6e91eedf5792be24439da6520fc78eda2ef30cbe96b65d6b787594baadaad5ca2c05c1915a1bd961253f3e1ca8bc30436931d83ee9626b2644656cb
-  data.tar.gz: 140be0447c460bc0e2ad56f45ac37133f7f6daed2cd101d749a7f207b6e14955a5de609565bf80004819ec5c47fc7048b1eaaed66a716edd181caa4d7135a9e9
+  metadata.gz: 98d35b11901102cb2d38f003bebbcd7cbfcc91de2d242a14ed8ce1f511fac0934cc941ac2399e0ef882c270540d6213b5d780316874196291798d839c7da3394
+  data.tar.gz: d9edd0cb14b47dc96e9aa58fa4caecb4ac57cf4d58bf378d03fd7e231c25e5807720624d1a3c6cdbfe486cc81e297881e7d8810ea1121920c7858072c400ee96

data/lib/fastlane/plugin/automated_test_emulator_run_mik/actions/automated_test_emulator_run_action.rb

@@ -17,7 +17,10 @@ module Fastlane
 
           # Create AVD_Controller class for each AVD_scheme
           for i in 0...avd_schemes.length 
-            avd_controller = Factory::AvdControllerFactory.get_avd_controller(params, avd_schemes[i])
+            port, f_port = generate_free_port()
+            UI.verbose(["Found port:", port].join(" "))
+
+            avd_controller = Factory::AvdControllerFactory.get_avd_controller(params, avd_schemes[i], port, f_port)
             avd_controllers << avd_controller
 
             if params[:verbose] 
@@ -106,7 +109,7 @@ module Fastlane
             # Wait for AVDs finish booting
             UI.message("Waiting for AVDs to finish booting.".yellow)
             UI.message("Performing wait for ADB boot".yellow)
-            adb_launch_complete = wait_for_emulator_boot_by_adb(adb_controller, avd_schemes, "#{params[:AVD_adb_launch_timeout]}")
+            adb_launch_complete = wait_for_emulator_boot_by_adb(adb_controller, avd_controllers, "#{params[:AVD_adb_launch_timeout]}")
 
             # Wait for AVD params finish booting
             if adb_launch_complete
@@ -154,8 +157,8 @@ module Fastlane
             if all_avd_launched
               UI.message("AVDs Booted!".green)
               if params[:logcat]
-                for i in 0...avd_schemes.length
-                  device = ["emulator-", avd_schemes[i].launch_avd_port].join('')
+                for i in 0...avd_controllers.length
+                  device = ["emulator-", avd_controllers[i].port].join('')
                   cmd = [adb_controller.adb_path, '-s', device, 'logcat -c'].join(' ')
                   Action.sh(cmd) unless devices.match(device).nil?
                 end
@@ -171,7 +174,7 @@ module Fastlane
                 end
                 
                 # Killing devices
-                unless devices.match(["emulator-", avd_schemes[i].launch_avd_port].join("")).nil?
+                unless devices.match(["emulator-", avd_controllers[i].port].join("")).nil?
                   Action.sh(avd_controllers[i].command_kill_device)
                   Process.kill("INT", pids[i])
                   Process.wait(pids[i])
@@ -193,7 +196,7 @@ module Fastlane
 
             unless gradle_task.nil?
               gradle = Helper::GradleHelper.new(gradle_path: Dir["./gradlew"].last)
-              serial = avd_schemes.map { |x| "emulator-" + x.launch_avd_port }.join(",")
+              serial = avd_controllers.map { |x| "emulator-" + x.port.to_s }.join(",")
 
               UI.message("Using gradle task.".green)
               gradle.trigger(task: params[:gradle_task], flags: params[:gradle_flags], serial: serial)
@@ -202,7 +205,7 @@ module Fastlane
             # Clean up
             for i in 0...avd_schemes.length
               # Kill all emulators
-              device = ["emulator-", avd_schemes[i].launch_avd_port].join("")
+              device = ["emulator-", avd_controllers[i].port].join("")
               unless devices.match(device).nil?
                 if params[:logcat]
                   file = [device, '.log'].join('')
@@ -237,7 +240,25 @@ module Fastlane
           end
         end
 
-        def self.wait_for_emulator_boot_by_adb(adb_controller, avd_schemes, timeout)
+        def self.generate_free_port()
+          FileUtils.mkdir_p '/tmp/automated_test_emulator_run'
+          for p in (6000..7000).step(2)
+            f = File.open("/tmp/automated_test_emulator_run/#{p}", File::RDWR | File::CREAT)
+            if f.flock(File::LOCK_EX | File::LOCK_NB)
+              return p, f
+            end
+
+            f.close()
+          end
+
+          raise("Error finding free port")
+        end
+
+        def clean_up_port(port, p_file)
+          p_file.flock(File::LOCK_UN)
+        end
+
+        def self.wait_for_emulator_boot_by_adb(adb_controller, avd_controllers, timeout)
           timeoutInSeconds= timeout.to_i
           interval = 1000 * 10
           startTime = Time.now
@@ -245,8 +266,8 @@ module Fastlane
           launch_status_hash = Hash.new
           device_visibility_hash = Hash.new
 
-          for i in 0...avd_schemes.length
-            device_name = ["emulator-", avd_schemes[i].launch_avd_port].join("")
+          for i in 0...avd_controllers.length
+            device_name = ["emulator-", avd_controllers[i].port].join("")
             launch_status_hash.store(device_name, false)
             device_visibility_hash.store(device_name, false)
           end
@@ -350,7 +371,7 @@ module Fastlane
                 device_boot_statuses.store(avd_schema.avd_name, avd_booted)
 
                 # Plotting current wait results
-                device_log = "Device 'emulator-" + avd_schemes[i].launch_avd_port.to_s + "' launch status:"
+                device_log = "Device 'emulator-" + avd_controllers[i].port.to_s + "' launch status:"
                 UI.message(device_log.magenta)
                 avd_param_boot_hash.each do |name, is_booted|
                   device_log = "'" + name + "' - '" + avd_param_status_hash[name].strip + "' (launched: " + is_booted.to_s + ")"
@@ -421,19 +442,19 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :AVD_recreate_new,
                                        env_name: "AVD_RECREATE_NEW",
                                        description: "Allow to decide if AVDs from AVD_setup.json (in case they already exist) should be deleted and created from scratch",
-                                       default_value: true,
+                                       default_value: false,
                                        is_string: false,
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :AVD_clean_after,
                                        env_name: "AVD_CLEAN_AFTER",
                                        description: "Allow to decide if AVDs should be deleted from PC after test session ends",
-                                       default_value: true,
+                                       default_value: false,
                                        is_string: false,
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :ADB_restart,
                                        env_name: "ADB_RESTART",
                                        description: "Allows to switch adb restarting on/off",
-                                       default_value: true,
+                                       default_value: false,
                                        is_string: false,
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :AVD_wait_for_bootcomplete,

data/lib/fastlane/plugin/automated_test_emulator_run_mik/factory/avd_controller_factory.rb

@@ -5,7 +5,7 @@ module Fastlane
 
     class AVD_Controller
         attr_accessor :command_install_package, :command_create_avd, :command_start_avd, :command_delete_avd, :command_apply_config_avd, :command_get_property, :command_kill_device,
-                      :output_file
+                      :output_file, :p_file, :port
 
         def self.create_output_file(params)
           output_file = Tempfile.new('emulator_output', '#{params[:AVD_path]}')
@@ -14,7 +14,7 @@ module Fastlane
 
     class AvdControllerFactory
   
-        def self.get_avd_controller(params, avd_scheme)
+        def self.get_avd_controller(params, avd_scheme, port, p_file)
           UI.message(["Preparing parameters and commands for emulator:", avd_scheme.avd_name].join(" ").yellow)
 
           # Get paths
@@ -55,7 +55,7 @@ module Fastlane
           sh_launch_emulator_binary = [path_sdk, "/emulator/", avd_scheme.launch_avd_launch_binary_name].join("")
           sh_launch_avd_name = ["-avd ", avd_scheme.avd_name].join("")
           sh_launch_avd_additional_options = avd_scheme.launch_avd_additional_options
-          sh_launch_avd_port = ["-port", avd_scheme.launch_avd_port].join(" ") 
+          sh_launch_avd_port = ["-port", port].join(" ") 
           
           if avd_scheme.launch_avd_snapshot_filepath.eql? ""
              sh_launch_avd_snapshot = ""
@@ -68,12 +68,14 @@ module Fastlane
 
           # ADB related shell command parts
           sh_specific_device = "-s"
-          sh_device_name_adb = ["emulator-", avd_scheme.launch_avd_port].join("")
+          sh_device_name_adb = ["emulator-", port].join("")
           sh_get_property = "shell getprop"
           sh_kill_device = "emu kill"
 
           # Assemble AVD controller
           avd_controller = AVD_Controller.new
+          avd_controller.p_file=p_file
+          avd_controller.port=port
           avd_controller.command_create_avd = [
             sh_create_answer_no, 
             path_avdmanager_binary,
@@ -90,6 +92,7 @@ module Fastlane
           
           avd_controller.command_start_avd = [
            sh_launch_emulator_binary, 
+           "-read-only",
            sh_launch_avd_port, 
            sh_launch_avd_name, 
            sh_launch_avd_snapshot, 

data/lib/fastlane/plugin/automated_test_emulator_run_mik/provider/avd_setup_provider.rb

@@ -3,7 +3,7 @@ module Fastlane
 
     class AVD_scheme
       attr_accessor :avd_name, :create_avd_package, :create_avd_device, :create_avd_tag, :create_avd_abi, :create_avd_hardware_config_filepath, :create_avd_additional_options, 
-                    :launch_avd_port, :launch_avd_launch_binary_name, :launch_avd_additional_options, :launch_avd_snapshot_filepath
+                    :launch_avd_launch_binary_name, :launch_avd_additional_options, :launch_avd_snapshot_filepath
     end
 
     class AvdSchemeProvider
@@ -34,7 +34,6 @@ module Fastlane
             avd_scheme.create_avd_abi = avd_hash['create_avd_abi']
             avd_scheme.create_avd_hardware_config_filepath = avd_hash['create_avd_hardware_config_filepath']
 
-            avd_scheme.launch_avd_port = avd_hash['launch_avd_port']
             avd_scheme.launch_avd_launch_binary_name = avd_hash['launch_avd_launch_binary_name']
             avd_scheme.launch_avd_additional_options = avd_hash['launch_avd_additional_options']
             avd_scheme.launch_avd_snapshot_filepath = avd_hash['launch_avd_snapshot_filepath']
@@ -48,74 +47,10 @@ module Fastlane
 
             avd_scheme_list << avd_scheme
           end
-          
-          # Prepare list of open ports for AVD_schemes without ports set in JSON
-          avaliable_ports = get_unused_even_tcp_ports(5556, 5586, avd_scheme_list)
-
-          # Fill empty AVD_schemes with open ports
-          for i in 0...avd_scheme_list.length
-            avd_scheme = avd_scheme_list[i]
-            if avd_scheme.launch_avd_port.eql? ""
-              avd_scheme.launch_avd_port = avaliable_ports[0]
-              avaliable_ports.delete(avaliable_ports[0])
-            end
-          end
 
           return avd_scheme_list
         end 
 
-        def self.get_unused_even_tcp_ports(min_port, max_port, avd_scheme_list) 
-          if min_port % 2 != 0
-            min_port += 1
-          end
-
-          if max_port % 2 != 0
-            max_port += 1
-          end
-
-          avaliable_ports = []
-          reserved_ports = []
-
-          # Gather ports requested in JSON config
-          for i in 0...avd_scheme_list.length
-            avd_scheme = avd_scheme_list[i]
-            unless avd_scheme.launch_avd_port.eql? ""
-              reserved_ports << avd_scheme.launch_avd_port
-            end
-          end
-
-          # Find next open port which wasn't reserved in JSON config
-          port = min_port
-          for i in 0...avd_scheme_list.length
-            
-            while port < max_port  do
-              if !system("lsof -i:#{port}", out: '/dev/null')
-
-                is_port_reserved = false
-                for j in 0...reserved_ports.length 
-                  if reserved_ports[j].eql?(port.to_s)
-                    is_port_reserved = true
-                    break
-                  end
-                end
-
-                if is_port_reserved
-                  port = port + 2
-                  break
-                end
-
-                avaliable_ports << port
-                port = port + 2
-                break
-              else 
-                port = port + 2
-              end
-            end
-          end
-
-          return avaliable_ports
-        end
-
         def self.read_avd_setup(params)
           if File.exists?(File.expand_path("#{params[:AVD_setup_path]}"))
             file = File.open(File.expand_path("#{params[:AVD_setup_path]}"), "rb")
@@ -154,9 +89,6 @@ module Fastlane
           if avd_scheme.launch_avd_launch_binary_name.nil?
             errors.push("launch_avd_launch_binary_name not found")
           end
-          if avd_scheme.launch_avd_port.nil? 
-              errors.push("launch_avd_port not found")
-          end
           if avd_scheme.launch_avd_additional_options.nil? 
               errors.push("launch_avd_additional_options not found")
           end

data/lib/fastlane/plugin/automated_test_emulator_run_mik/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module AutomatedTestEmulatorRunMik
-    VERSION = "1.6.14"
+    VERSION = "1.6.15-1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-automated_test_emulator_run_mik
 version: !ruby/object:Gem::Version
-  version: 1.6.14
+  version: 1.6.15.pre.1
 platform: ruby
 authors:
 - Kamil Krzyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-04 00:00:00.000000000 Z
+date: 2019-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -123,9 +123,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.2.3