fastlane-plugin-mango 1.1.3 → 1.3.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9194c8b391c61584dc3f7869e34408e9ea8cbd3bd83e358411eb88991047867e
-  data.tar.gz: 77a3155ba799fab155fef7c91f28c77b92e60e68ab89354d69b1b498bd1fb31b
+  metadata.gz: c5e9db6561834f87bc0a4c5607f7ca117532d38d35f846ed6a389e16c7da3223
+  data.tar.gz: fbdff88d36c647a249c76c58a9345e5aee75a23bc231ffcd01f86986bad41357
 SHA512:
-  metadata.gz: 8f4ec7d68b57f29587b863d1e4b7c198b0bec97034ff2da5e6aa7097be4ea02d97331fc378859f6a383de49cbd5a9d66609677b05fd226af0d92c0f617a1ab9d
-  data.tar.gz: 69b0e5012298849306f3bc138f67311615040d14af7be6657c7cb097be136f435b842ca846ff7a54f53a1954899573dcd7968173ac97836acb4fc38d1ee143dc
+  metadata.gz: 3e015e871f2eceac9afb44618dab0023819f96d3066d709b540f2e7fdd4a830c970897d192f6ac0ac36a73d06fffb7992805a1ccc8f813439d3144d3a7abf569
+  data.tar.gz: 077d01545b646eea107ac015b1d7f847d8ffe41a66f1c33786ae0318d39b71e7ae6321564b9a420121f86c0676ae1150ce42774c57e00240694324fcb912f522

data/README.md

@@ -78,6 +78,7 @@ The `mango` action has plenty of options to configure it.
 | `docker_image` | Name of the Docker image, that should be started and used to run your tasks. | butomo1989/docker-android-x86-5.1.1 | ❌ | `String` |
 | `container_timeout` | Timeout (in seconds) to get a healthy docker container. Depending on your `docker_image` it may take some time until it's started up and ready to use. | 450 (this equals 7.5 minutes) | ❌ | `Integer` |
 | `android_task` | A generic Android task you want to execute. | - | ❌ | `String` |
+| `core_amount` | Cpu core amount while starting docker container with limited resource. | - | ✅ | `Integer` |
 | `sdk_path` | The path to your Android sdk directory. | `ANDROID_HOME` environment variable | ✅ | `String` |
 | `port_factor` | Base for calculating a unique port for noVNC. We recommend to use the `EXECUTOR_NUMBER` from your Jenkins environment. | - | ✅ | `String` |
 | `workspace_dir` | Path to the workspace to execute commands. If you want to execute your `android_task` from a different directory you have to specify `workspace_dir`. | `/root/tests/` | ✅ | `String` |

data/lib/fastlane/plugin/mango/actions/run_dockerized_task_action.rb

@@ -4,7 +4,9 @@ module Fastlane
   module Actions
     class RunDockerizedTaskAction < Action
       def self.run(params)
-        UI.important("The mango plugin is working!")
+        UI.important('The mango plugin is working!')
+        workspace_dir = params[:workspace_dir]
+        ENV['DOCKER_CONFIG'] = "#{ENV['WORKSPACE']}/.docker"
         mango_helper = Fastlane::Helper::MangoHelper.new(params)
         mango_helper.setup_container
 
@@ -12,32 +14,45 @@ module Fastlane
 
         failure_buffer_timeout = 5
         timeout_command = "timeout #{params[:maximal_run_time] - failure_buffer_timeout}m"
-        workspace_dir = params[:workspace_dir]
 
         android_task = params[:android_task]
         if android_task
-          UI.success("Starting Android Task.")
+          UI.success('Starting Android Task.')
           bundle_install = params[:bundle_install] ? '&& bundle install ' : ''
 
           docker_commander.exec(command: "cd #{workspace_dir} #{bundle_install}&& #{timeout_command} #{android_task} || exit 1")
         end
-
+      rescue StandardError => e
+        begin
+          Actions.sh("docker logs #{mango_helper.container_name} --tail 200")
+        rescue StandardError
+          # do nothing
+        end
+        docker_commander.exec(command:
+                                  'cat /var/log/supervisor/docker-android.stderr.log', raise_when_fail: false)
+        docker_commander.exec(command: 'cat /var/log/supervisor/supervisord.log',
+                              raise_when_fail: false)
+        raise e
       ensure
-        post_actions = params[:post_actions]
-        if post_actions && !mango_helper.kvm_disabled?
-          docker_commander&.exec(command: "cd #{workspace_dir} && #{post_actions}")
+        begin
+          post_actions = params[:post_actions]
+          if post_actions && !mango_helper.kvm_disabled?
+            docker_commander&.exec(command: "cd #{workspace_dir} && #{post_actions}")
+          end
+
+          UI.important("Cleaning up #{params[:emulator_name]} container")
+          docker_commander.delete_container if mango_helper&.instance_variable_get('@container')
+        rescue StandardError => e
+          puts e
         end
-
-        UI.important("Cleaning up #{params[:emulator_name]} container")
-        mango_helper.clean_container if mango_helper&.instance_variable_get('@container')
       end
 
       def self.description
-        "Action that runs Android tasks on a specified Docker image"
+        'Action that runs Android tasks on a specified Docker image'
       end
 
       def self.authors
-        ["Serghei Moret", "Daniel Hartwich"]
+        ['Serghei Moret', 'Daniel Hartwich']
       end
 
       def self.return_value
@@ -50,123 +65,144 @@ module Fastlane
 
       def self.details
         # Optional:
-        ""
+        ''
       end
 
       def self.available_options
         [
           FastlaneCore::ConfigItem.new(key: :container_name,
-                                      env_name: "CONTAINER_NAME",
-                                      description: "Name of the docker container. Will be generated randomly if not defined",
-                                      optional: true,
-                                      type: String),
+                                       env_name: 'CONTAINER_NAME',
+                                       description: 'Name of the docker container. Will be generated randomly if not defined',
+                                       optional: true,
+                                       type: String),
 
           FastlaneCore::ConfigItem.new(key: :no_vnc_port,
-                                       env_name: "NO_VNC_PORT",
-                                       description: "Port to redirect noVNC. 6080 by default",
+                                       env_name: 'NO_VNC_PORT',
+                                       description: 'Port to redirect noVNC. 6080 by default',
                                        default_value: 6080,
                                        optional: false,
                                        type: Integer),
 
           FastlaneCore::ConfigItem.new(key: :device_name,
-                                       env_name: "DEVICE_NAME",
-                                       description: "Name of the Android device. Nexus 5X by default",
+                                       env_name: 'DEVICE_NAME',
+                                       description: 'Name of the Android device. Nexus 5X by default',
                                        default_value: 'Nexus 5X',
                                        optional: false,
                                        type: String),
 
           FastlaneCore::ConfigItem.new(key: :emulator_name,
-                                       env_name: "EMULATOR_NAME",
-                                       description: "Name of the Android emulator. emulator-5554 by default",
+                                       env_name: 'EMULATOR_NAME',
+                                       description: 'Name of the Android emulator. emulator-5554 by default',
                                        default_value: 'emulator-5554',
                                        optional: false,
                                        type: String),
 
           FastlaneCore::ConfigItem.new(key: :docker_image,
-                                       env_name: "DOCKER_IMAGE",
-                                       description: "Name of the Docker image. butomo1989/docker-android-x86-5.1.1 by default",
+                                       env_name: 'DOCKER_IMAGE',
+                                       description: 'Name of the Docker image. butomo1989/docker-android-x86-5.1.1 by default',
                                        default_value: 'butomo1989/docker-android-x86-5.1.1',
                                        optional: false,
                                        type: String),
 
           FastlaneCore::ConfigItem.new(key: :container_timeout,
-                                      env_name: "CONTAINER_TIMEOUT",
-                                      description: "Timeout (in seconds) to get the healthy docker container. 450 (7.5 minutes) by default",
-                                      default_value: 450,
-                                      optional: false,
-                                      type: Integer),
-
-         FastlaneCore::ConfigItem.new(key: :android_task,
-                                      env_name: "ANDROID TASK",
-                                      description: "A generic Android task you want to execute",
-                                      is_string: true,
-                                      optional: false),
+                                       env_name: 'CONTAINER_TIMEOUT',
+                                       description: 'Timeout (in seconds) to get the healthy docker container. 450 (7.5 minutes) by default',
+                                       default_value: 450,
+                                       optional: false,
+                                       type: Integer),
+
+          FastlaneCore::ConfigItem.new(key: :android_task,
+                                       env_name: 'ANDROID TASK',
+                                       description: 'A generic Android task you want to execute',
+                                       is_string: true,
+                                       optional: false),
 
           FastlaneCore::ConfigItem.new(key: :sdk_path,
-                                       env_name: "SDK_PATH",
-                                       description: "The path to your Android sdk directory (root). ANDROID_HOME by default",
+                                       env_name: 'SDK_PATH',
+                                       description: 'The path to your Android sdk directory (root). ANDROID_HOME by default',
                                        default_value: ENV['ANDROID_HOME'],
                                        is_string: true,
                                        optional: true),
 
           FastlaneCore::ConfigItem.new(key: :port_factor,
-                                      env_name: "PORT_FACTOR",
-                                      description: "Base for calculating a unique port for noVNC. You can pass EXECUTOR_NUMBER from Jenkins for example, this will be unique and not clash in case of several instances running on the same machine",
-                                      optional: true,
-                                      type: String),
+                                       env_name: 'PORT_FACTOR',
+                                       description: 'Base for calculating a unique port for noVNC. You can pass EXECUTOR_NUMBER from Jenkins for example, this will be unique and not clash in case of several instances running on the same machine',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :core_amount,
+                                       env_name: 'CORE_AMOUNT',
+                                       default_value: 0,
+                                       description: 'Define if we want to start docker container with the limitation',
+                                       optional: true,
+                                       type: Integer),
 
           FastlaneCore::ConfigItem.new(key: :workspace_dir,
-                                       env_name: "WORKSPACE_DIR",
+                                       env_name: 'WORKSPACE_DIR',
                                        default_value: '/root/tests/',
-                                       description: "Path to the workspace to execute commands. If you want to execute your `android_task` from a different directory you have to specify `workspace_dir`",
+                                       description: 'Path to the workspace to execute commands. If you want to execute your `android_task` from a different directory you have to specify `workspace_dir`',
                                        optional: true,
                                        type: String),
 
           FastlaneCore::ConfigItem.new(key: :maximal_run_time,
-                                       env_name: "MAXIMAL_RUN_TIME",
+                                       env_name: 'MAXIMAL_RUN_TIME',
                                        default_value: 60,
-                                       description: "Defines the maximal time of your test run. Defaults to 60 minutes",
+                                       description: 'Defines the maximal time of your test run. Defaults to 60 minutes',
                                        optional: true,
                                        type: Integer),
 
           FastlaneCore::ConfigItem.new(key: :bundle_install,
-                                       env_name: "BUNDLE_INSTALL",
+                                       env_name: 'BUNDLE_INSTALL',
                                        default_value: false,
-                                       description: "Defines if the Android task must execute bundle install before running a build",
+                                       description: 'Defines if the Android task must execute bundle install before running a build',
                                        optional: true,
                                        type: Boolean),
 
           FastlaneCore::ConfigItem.new(key: :is_running_on_emulator,
-                                       env_name: "IS_RUNNING_ON_EMULATOR",
+                                       env_name: 'IS_RUNNING_ON_EMULATOR',
                                        default_value: true,
-                                       description: "Define if we want to run the emulator in the container",
+                                       description: 'Define if we want to run the emulator in the container',
                                        optional: true,
                                        type: Boolean),
 
           FastlaneCore::ConfigItem.new(key: :post_actions,
-                                      env_name: "POST_ACTIONS",
-                                      description: "Actions that will be executed after the main command has been executed",
-                                      is_string: true,
-                                      optional: true),
+                                       env_name: 'POST_ACTIONS',
+                                       description: 'Actions that will be executed after the main command has been executed',
+                                       is_string: true,
+                                       optional: true),
 
           FastlaneCore::ConfigItem.new(key: :pre_action,
-                                      env_name: "PRE_ACTION",
-                                      description: "Actions that will be executed before the docker image gets pulled",
-                                      is_string: true,
-                                      optional: true),
+                                       env_name: 'PRE_ACTION',
+                                       description: 'Actions that will be executed before the docker image gets pulled',
+                                       is_string: true,
+                                       optional: true),
 
           FastlaneCore::ConfigItem.new(key: :docker_registry_login,
-                                      env_name: "DOCKER_REGISTRY_LOGIN",
-                                      description: "Authenticating yourself to a custom Docker registry",
-                                      type: String,
-                                      optional: true),
+                                       env_name: 'DOCKER_REGISTRY_LOGIN',
+                                       description: 'Authenticating yourself to a custom Docker registry',
+                                       type: String,
+                                       optional: true),
 
           FastlaneCore::ConfigItem.new(key: :pull_latest_image,
-                                      env_name: "PULL_LATEST_IMAGE",
-                                      description: "Define if you want to pull the latest image",
-                                      type: Boolean,
-                                      default_value: false,
-                                      optional: true)
+                                       env_name: 'PULL_LATEST_IMAGE',
+                                       description: 'Define if you want to pull the latest image',
+                                       type: Boolean,
+                                       default_value: false,
+                                       optional: true),
+
+          FastlaneCore::ConfigItem.new(key: :environment_variables,
+                                       env_name: 'ENVIRONMENT_VARIABLES',
+                                       description: 'Comma seperated list of environment variables which are passed into the docker container',
+                                       type: Array,
+                                       default_value: [],
+                                       optional: true),
+
+          FastlaneCore::ConfigItem.new(key: :vnc_enabled,
+                                       env_name: 'VNC_ENABLED',
+                                       description: 'A bool. True for vnc_enabled False for vnc_disabled',
+                                       type: Boolean,
+                                       default_value: true,
+                                       optional: true)
         ]
       end
     end

data/lib/fastlane/plugin/mango/helper/cpu_load_handler.rb

@@ -0,0 +1,40 @@
+require 'os'
+
+module Fastlane
+  module Helper
+    module CpuLoadHandler
+      def self.print_cpu_load(load = cpu_load)
+        UI.important("CPU load is: #{load}") if load
+      end
+
+      # Gets load average of Linux machine
+      def self.cpu_load
+        load = Actions.sh('cat /proc/loadavg')
+        load.split(' ').first.to_f unless load.empty?
+      end
+
+      # Gets amount of the CPU cores
+      def self.cpu_core_amount
+        Actions.sh("cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1")
+      end
+
+      # For half an hour waiting until CPU load average is less than number of cores*2 (which considers that CPU is ready)
+      # Raises when 30 minutes timeout exceeds
+      def self.wait_cpu_to_idle
+        if OS.linux?
+          30.times do
+            load = cpu_load
+            return true if load <= cpu_core_amount.to_i * 1.5
+
+            print_cpu_load(load)
+            UI.important('Waiting for available resources..')
+            sleep 60
+          end
+        else
+          return true
+        end
+        raise "CPU was overloaded. Couldn't start emulator"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/mango/helper/docker_commander.rb

@@ -1,10 +1,8 @@
 require 'docker'
-require 'os'
 
 module Fastlane
   module Helper
     class DockerCommander
-
       attr_accessor :container_name
 
       def initialize(container_name)
@@ -12,66 +10,63 @@ module Fastlane
       end
 
       def pull_image(docker_image_name:)
-        handle_thin_pool_exception do
-          Actions.sh("docker pull #{docker_image_name}")
-        end
+        Actions.sh("docker pull #{docker_image_name}")
+      rescue StandardError => e
+        prune if e.message =~ /Create more free space in thin pool/
+        Actions.sh("docker pull #{docker_image_name}")
       end
 
-      def start_container(emulator_args:, docker_image:)
+      def start_container(emulator_args:, docker_image:, core_amount:)
+        retries ||= 0
         docker_name = if container_name
                         "--name #{container_name}"
                       else
                         ''
                       end
+        # if core_amount value is defined then limit the container while starting
+        core_amount = if core_amount && core_amount > 0
+                        "--cpus=#{core_amount}"
+                      else
+                        ''
+                      end
 
         # Action.sh returns all output that the command produced but we are only
         # interested in the last line, since it contains the id of the created container.
         UI.important("Attaching #{ENV['PWD']} to the docker container")
-        handle_thin_pool_exception do
-          Actions.sh("docker run -v $PWD:/root/tests --privileged -t -d #{emulator_args} #{docker_name} #{docker_image}").chomp
+        Actions.sh("docker run -v $PWD:/root/tests --privileged -t -d #{core_amount} #{emulator_args} #{docker_name} #{docker_image}").chomp
+      rescue StandardError => e
+        if e.message =~ /Create more free space in thin pool/ && (retries += 1) < 2
+          prune
+          retry
         end
       end
 
-      def stop_container
-        Actions.sh("docker stop #{container_name}") if container_name
-      end
-
       def delete_container
-        Actions.sh("docker rm #{container_name}") if container_name
+        Actions.sh("docker rm -f #{container_name}") if container_name
       end
 
       def disconnect_network_bridge
+        UI.important('Disconnecting from the network bridge')
         Actions.sh("docker network disconnect -f bridge #{container_name}") if container_name
       rescue StandardError
         # Do nothing if the network bridge is already gone
       end
 
-      def exec(command:)
+      def exec(command:, raise_when_fail: true)
         if container_name
-          Actions.sh("docker exec -i #{container_name} bash -l -c \"#{command}\"")
+          begin
+            Actions.sh("docker exec #{container_name} bash -l -c \"#{command}\"")
+          rescue StandardError => e
+            raise(e) if raise_when_fail
+          end
         else
           raise('Cannot execute docker command because the container name is unknown')
         end
       end
-        
+
       def prune
         Action.sh('docker system prune -f')
       end
-
-      def handle_thin_pool_exception(&block)
-        begin
-          block.call
-        rescue FastlaneCore::Interface::FastlaneShellError => exception
-          retry_counter = retry_counter.to_i + 1
-          if exception.message =~ /Create more free space in thin pool/ && retry_counter < 2
-            prune
-            retry
-          else
-            raise exception
-          end
-        end
-      end
-
     end
   end
-end
+end

data/lib/fastlane/plugin/mango/helper/emulator_commander.rb

@@ -2,9 +2,7 @@ require_relative 'docker_commander'
 
 module Fastlane
   module Helper
-
     class EmulatorCommander
-
       attr_accessor :container_name
 
       def initialize(container_name)
@@ -22,7 +20,7 @@ module Fastlane
         # it recovers after some time, so wait and retry
         retry_counter = retry_counter.to_i + 1
         if retry_counter <= 5
-          sleep 10*retry_counter
+          sleep 10 * retry_counter
           retry
         else
           raise e
@@ -50,7 +48,17 @@ module Fastlane
       def emulator_is_healthy?
         list_devices = @docker_commander.exec(command: 'adb devices')
         list_devices.include? "\tdevice"
+      rescue FastlaneCore::Interface::FastlaneShellError => e
+        # Under weird circumstances it can happen that adb is running but adb is not completely up
+        # it recovers after some time, so wait and retry
+        retry_counter = retry_counter.to_i + 1
+        if retry_counter <= 5
+          sleep 10 * retry_counter
+          retry
+        else
+          raise e
+        end
       end
     end
   end
-end
+end

data/lib/fastlane/plugin/mango/helper/mango_helper.rb

@@ -1,14 +1,13 @@
-require 'docker'
-require 'timeout'
-require 'os'
 require 'net/http'
 require_relative 'docker_commander'
 require_relative 'emulator_commander'
+require_relative 'cpu_load_handler'
 
 module Fastlane
   module Helper
     class MangoHelper
-      attr_reader :container_name, :no_vnc_port, :device_name, :docker_image, :timeout, :port_factor, :maximal_run_time, :sleep_interval, :is_running_on_emulator
+      attr_reader :container_name, :no_vnc_port, :device_name, :docker_image, :timeout, :port_factor,
+                  :maximal_run_time, :sleep_interval, :is_running_on_emulator, :environment_variables, :vnc_enabled, :core_amount
 
       def initialize(params)
         @container_name = params[:container_name]
@@ -18,6 +17,7 @@ module Fastlane
         @timeout = params[:container_timeout]
         @sdk_path = params[:sdk_path]
         @port_factor = params[:port_factor].to_i
+        @core_amount = params[:core_amount].to_i
         @maximal_run_time = params[:maximal_run_time]
         @sleep_interval = 5
         @container = nil
@@ -26,7 +26,8 @@ module Fastlane
         @pre_action = params[:pre_action]
         @docker_registry_login = params[:docker_registry_login]
         @pull_latest_image = params[:pull_latest_image]
-        
+        @environment_variables = params[:environment_variables]
+        @vnc_enabled = params[:vnc_enabled]
         @docker_commander = DockerCommander.new(container_name)
         @emulator_commander = EmulatorCommander.new(container_name)
       end
@@ -40,13 +41,11 @@ module Fastlane
         assign_unique_vnc_port if port_factor && is_running_on_emulator
 
         if container_available?
-          @container.stop
-          @container.delete(force: true)
+          UI.important('Container was already started. Stopping and removing..')
+          @docker_commander.delete_container
         end
 
-        handle_ports_allocation if is_running_on_emulator
-
-        execute_pre_action if @pre_action
+        handle_ports_allocation if is_running_on_emulator && vnc_enabled
 
         pull_from_registry if @pull_latest_image
 
@@ -67,14 +66,20 @@ module Fastlane
         end
 
         unless container_state
-          UI.important("Will retry checking for a healthy docker container after #{sleep_interval} seconds")
-          @container.stop
-          @container.delete(force: true)
+          UI.important("Will retry to create a healthy docker container after #{sleep_interval} seconds")
+          @docker_commander.delete_container
           sleep @sleep_interval
           create_container
 
           unless wait_for_healthy_container
             UI.important('Container is unhealthy. Exiting..')
+            begin
+              Actions.sh("docker logs #{container_name} --tail 200")
+              Actions.sh("docker exec -i #{container_name} cat /var/log/supervisor/docker-android.stderr.log")
+              Actions.sh("docker exec -i #{container_name} cat /var/log/supervisor/supervisord.log")
+            rescue StandardError
+              # do nothing
+            end
             # We use code "2" as we need something than just standard error code 1, so we can differentiate the next step in CI
             exit 2
           end
@@ -89,6 +94,8 @@ module Fastlane
           @emulator_commander.disable_animations
           @emulator_commander.increase_logcat_storage
         end
+
+        execute_pre_action if @pre_action
       end
 
       def kvm_disabled?
@@ -100,12 +107,6 @@ module Fastlane
         @docker_commander.exec(command: 'cat kvm-ok.txt').include?('KVM acceleration can NOT be used')
       end
 
-      # Stops and remove container
-      def clean_container
-        @container.stop
-        @container.delete(force: true)
-      end
-
       private
 
       # Sets path to adb
@@ -116,7 +117,7 @@ module Fastlane
       # assigns vnc port
       def assign_unique_vnc_port
         @no_vnc_port = 6080 + port_factor
-        @host_ip_address = `hostname -I | head -n1 | awk '{print $1;}'`.delete!("\n")
+        @host_ip_address = `hostname -i | head -n1 | awk '{print $1;}'`.delete!("\n")
         UI.success("Port: #{@no_vnc_port} was chosen for VNC")
         UI.success("Link to VNC: http://#{@host_ip_address}:#{@no_vnc_port}")
       end
@@ -124,49 +125,55 @@ module Fastlane
       # Creates new container using params
       def create_container
         UI.important("Creating container: #{container_name}")
-        print_cpu_load
+        CpuLoadHandler.print_cpu_load
         begin
           container = create_container_call
           set_container_name(container)
         rescue StandardError
           UI.important("Something went wrong while creating: #{container_name}, will retry in #{@sleep_interval} seconds")
-          print_cpu_load
-          @docker_commander.stop_container
+          CpuLoadHandler.print_cpu_load
           @docker_commander.delete_container
-          
           sleep @sleep_interval
           container = create_container_call
           set_container_name(container)
         end
-        get_container_instance(container)
+        @container = get_container_instance(container)
+
+        if @container.nil?
+          sleep 3
+          @container = get_container_instance(container)
+        end
       end
 
       # Gets container instance by container ID
       def get_container_instance(container)
         Docker::Container.all(all: true).each do |cont|
-          if cont.id == container
-            @container = cont
-            break
-          end
+          return cont if cont.id == container
         end
       end
 
       # Call to create a container. We don't use Docker API here, as it doesn't support --privileged.
       def create_container_call
         # When CPU is under load we cannot create a healthy container
-        wait_cpu_to_idle
+        CpuLoadHandler.wait_cpu_to_idle
 
+        additional_env = ''
+        environment_variables.each do |variable|
+          additional_env += " -e #{variable}"
+        end
         emulator_args = is_running_on_emulator ? "-p #{no_vnc_port}:6080 -e DEVICE='#{device_name}'" : ''
-
-        @docker_commander.start_container(emulator_args: emulator_args, docker_image: docker_image)
+        emulator_args = "#{emulator_args}#{additional_env}"
+        @docker_commander.start_container(emulator_args: emulator_args, docker_image: docker_image,
+                                          core_amount: core_amount)
       end
 
       def execute_pre_action
-        Actions.sh(@pre_action)
+        @docker_commander.exec(command: @pre_action)
       end
 
       # Pull the docker images before creating a container
       def pull_from_registry
+        UI.important('Pulling the :latest image from the registry')
         docker_image_name = docker_image.gsub(':latest', '')
         Actions.sh(@docker_registry_login) if @docker_registry_login
         @docker_commander.pull_image(docker_image_name: docker_image_name)
@@ -183,7 +190,6 @@ module Fastlane
         if port_open?('0.0.0.0', @no_vnc_port)
           UI.important('Something went wrong. VNC port is still busy')
           sleep @sleep_interval
-          @docker_commander.stop_container
           @docker_commander.delete_container
         end
       end
@@ -197,17 +203,14 @@ module Fastlane
         nil
       end
 
-      def print_cpu_load(load = cpu_load)
-        UI.important("CPU load is: #{load}")
-      end
-
       # Checks if container is already available
       def container_available?
         return false unless container_name
+
         all_containers = Docker::Container.all(all: true)
 
         all_containers.each do |container|
-          if container.info['Names'].first[1..-1] == container_name
+          if container.info['Names'].first[1..] == container_name
             @container = container
             return true
           end
@@ -246,6 +249,9 @@ module Fastlane
         end
         UI.important("The Container failed to load after '#{timeout}' seconds timeout. Reason: '#{@container.json['State']['Status']}'")
         false
+      rescue StandardError => e
+        puts e
+        false
       end
 
       # Checks if port is already openZ
@@ -257,41 +263,12 @@ module Fastlane
         false
       end
 
-      # Gets load average of Linux machine
-      def cpu_load
-        load = `cat /proc/loadavg`
-        load.split(' ').first.to_f
-      end
-
-      # Gets amount of the CPU cores
-      def cpu_core_amount
-        `cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1`
-      end
-
-      # For half an hour waiting until CPU load average is less than number of cores*2 (which considers that CPU is ready)
-      # Raises when 30 minutes timeout exceeds
-      def wait_cpu_to_idle
-        if OS.linux?
-          30.times do
-            load = cpu_load
-            return true if load < cpu_core_amount.to_i * 1.5
-            print_cpu_load(load)
-            UI.important('Waiting for available resources..')
-            sleep 60
-          end
-        else
-          return true
-        end
-        raise "CPU was overloaded. Couldn't start emulator"
-      end
-
       # if we do not have container name, we cane use container ID that we got from create call
       def set_container_name(container)
         unless container_name
           @container_name = @emulator_commander.container_name = @docker_commander.container_name = container
         end
       end
-
     end
   end
 end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Mango
-    VERSION = '1.1.3'.freeze
+    VERSION = '1.3.23'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-mango
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.3.23
 platform: ruby
 authors:
 - Serghei Moret, Daniel Hartwich
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-09-03 00:00:00.000000000 Z
+date: 2021-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docker-api
@@ -112,16 +112,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.58.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.58.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -136,7 +136,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: serghei.moret@xing.com, hartwich.daniel@gmail.com
 executables: []
 extensions: []
@@ -146,6 +146,7 @@ files:
 - README.md
 - lib/fastlane/plugin/mango.rb
 - lib/fastlane/plugin/mango/actions/run_dockerized_task_action.rb
+- lib/fastlane/plugin/mango/helper/cpu_load_handler.rb
 - lib/fastlane/plugin/mango/helper/docker_commander.rb
 - lib/fastlane/plugin/mango/helper/emulator_commander.rb
 - lib/fastlane/plugin/mango/helper/mango_helper.rb
@@ -154,7 +155,7 @@ homepage: https://github.com/xing/mango
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -169,9 +170,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.4
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: This plugin Android tasks on docker images
 test_files: []