fastlane-plugin-mango 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 75221491bc8b2b1f16e769b0208203efbd55ac56a5577a632e522b1caa5348ba
+  data.tar.gz: facf07278586a34970216bf5bef7984bdd0e2cebb9854ae2f75e84d62693f310
+SHA512:
+  metadata.gz: be523d5eaaf2475812c9aac88e1a82a8135b06649228d0c6684d3201064d4fceeaf28551dfcef541a5b820c8bb27d11bee76bfdb99e78a05600240585cf2c818
+  data.tar.gz: f095125f165f15695d06fb6d11589c57a61be876fb54bf1f9201919289ac93532c1d1f0eafd74af29577f062ab6a210539ec9a2b60fd3b2e22662a57faa1a9b4

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2017 XING SE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,127 @@
+
+# Mango - Fastlane plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-mango)
+
+A fastlane plugin that runs Android tasks on a specified [Docker](https://www.docker.com/) image
+
+<img src="assets/mango_logo.png" alt="Mango Logo" width="256px" height="256px"/>
+
+Running Android tests, especially [Espresso](https://developer.android.com/training/testing/espresso/) on a continuous integration environment like [Jenkins](https://jenkins.io/) can be a hassle. You need to boot, manage and destroy an [Android Virtual Device (AVD)](https://developer.android.com/studio/run/managing-avds) during the test run. This is why we, the mobile releases team at [XING](https://www.xing/com), built this plugin. It spins up a specified [Docker](https://www.docker.com/) image and runs a given task on it.
+
+Another requirement we had was to run on a clean environment, which is why Mango also helps us to run our unit test and more. For an example check out the [example `Fastfile`](sample-android/fastlane/Fastfile)
+
+## Prerequisites
+
+In order to use this plugin you will need to to have [Docker](https://www.docker.com/) installed on the machine you are using.
+Documentation on how to set it up properly on a Linux (ubuntu) machine can be found [here](docs/docker-linux.md).
+
+If you need an Android Virtual Device (AVD) to run your tests (for example Espresso, Calabash or Appium), it's necessary to check that your CPU supports kvm virtualisation. We already experienced, that it doesn't fully work on macOS and are using Linux for that.
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-mango`, add it to your project by running:
+
+```bash
+fastlane add_plugin mango
+```
+
+## Usage
+
+After installing this plugin you have access to one additional action (`mango`) in your `Fastfile`.
+
+So a lane in your `Fastfile` could look similar to this:
+```ruby
+desc "Run espresso tests on docker images"
+  lane :Espresso_Tests do |options|
+     mango(
+       container_name: "espresso_container",
+       docker_image: "thyrlian/android-sdk:latest",
+       container_timeout: 120,
+       android_task: "./gradlew connectedAndroidTest",
+       post_actions: "adb logcat -d > logcat.txt"          
+     )
+   end
+```
+
+Now you can call this new lane by calling `bundle exec fastlane Espresso_Tests`.
+
+The Plugin will start up the given `docker_image`, execute the given `android_task` and afterwards execute the `post_actions`.
+
+Of
+
+## Configuration options
+The `mango` action has plenty of options to configure it.
+
+| Option | Description | Default value | Optional | Type |
+| - |:-|-:| :-:| -:|
+| `container_name`| Name of the docker container. Will be generated randomly if not defined. | - | ✅ | `String` |
+| `no_vnc_port` | Port to redirect noVNC. To observe your docker container from your browser while it's running. | 6080 | ❌ | `Integer` |
+| `device_name` | Name of the Android device. | Nexus 5X | ❌ | `String` |
+| `emulator_name`| Name of the Android emulator. | emulator-5554 | ❌ | `String` |
+| `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` |
+| `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` |
+| `maximal_run_time` | Defines the maximal time of your test run in minutes. This can be helpful if you want to kill hanging processes automatically after a certain time. | 60 | ✅ | `Integer` |
+| `bundle_install` | Defines if the Android task must execute `bundle install` before running a build. This is useful if you want to execute non-gradle tasks. Like [Calabash](https://github.com/calabash/calabash-android), where you need to update/install your [Ruby](https://www.ruby-lang.org) dependencies. | `true` | ✅ | `Boolean` |
+| `is_running_on_emulator` | Define if container boots up an emulator instance inside of it. This will trigger configuration of noVNC, assign necessary ports etc. | `true` | ✅ | `Boolean` |
+| `post_actions` | Actions that will be executed after the main command has been executed. | - | ✅ | `String` |
+| `pre_action` | Actions that will be executed before the docker image gets pulled | - | ✅ | `String` |
+| `docker_registry_login` | Command to authenticate yourself in a custom Docker registry | - | ✅ | `String` |
+| `pull_latest_image` | Defines if you want to pull the `:latest` tag of the given `docker_image` | `false` | ✅ | `Boolean` |
+
+## Contributing
+
+🎁 Bug reports and pull requests for new features are most welcome!
+
+👷🏼 We are looking forward to your pull request, we'd love to help!
+
+You can help by doing any of the following:
+
+- Reviewing pull requests
+- Bringing ideas for new features
+- Answering questions on issues
+- Improving documentation
+
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant code](http://contributor-covenant.org/) of conduct.
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## License
+
+The fastlane plugin is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Example
+
+Check out the [example `Fastfile`](sample-android/fastlane/Fastfile) to see how to use this plugin.
+Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+## Run tests for this plugin
+
+To run both the tests and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/mango.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/mango/version'
+
+module Fastlane
+  module Mango
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::Mango.all_classes.each do |current|
+  require current
+end

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

@@ -0,0 +1,171 @@
+module Fastlane
+  module Actions
+    class RunDockerizedTaskAction < Action
+      def self.run(params)
+        UI.important("The mango plugin is working!")
+        emulator_name = params[:emulator_name]
+        docker_emulator = Fastlane::Helper::MangoHelper.new(params)
+        docker_emulator.setup_container
+
+        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.")
+          bundle_install = params[:bundle_install] ? '&& bundle install ' : ''
+
+          docker_emulator.docker_exec("cd #{workspace_dir} #{bundle_install}&& #{timeout_command} #{android_task} || exit 1")
+        end
+
+      ensure
+        post_actions = params[:post_actions]
+        if post_actions
+          docker_emulator&.docker_exec("cd #{workspace_dir} && #{post_actions}")
+        end
+
+        UI.important("Cleaning up #{emulator_name} container")
+        docker_emulator.clean_container if docker_emulator.instance_variable_get('@container')
+      end
+
+      def self.description
+        "Action that runs Android tasks on a specified Docker image"
+      end
+
+      def self.authors
+        ["Serghei Moret", "Daniel Hartwich"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      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),
+
+          FastlaneCore::ConfigItem.new(key: :no_vnc_port,
+                                       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",
+                                       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",
+                                       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",
+                                       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),
+
+          FastlaneCore::ConfigItem.new(key: :sdk_path,
+                                       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),
+
+          FastlaneCore::ConfigItem.new(key: :workspace_dir,
+                                       env_name: "WORKSPACE_DIR",
+                                       default_value: '/root/tests/',
+                                       description: "Path to the workspace to execute commands",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :maximal_run_time,
+                                       env_name: "MAXIMAL_RUN_TIME",
+                                       default_value: 60,
+                                       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",
+                                       default_value: false,
+                                       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",
+                                       default_value: true,
+                                       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),
+
+          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),
+
+          FastlaneCore::ConfigItem.new(key: :docker_registry_login,
+                                      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)
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,310 @@
+require 'docker'
+require 'socket'
+require 'timeout'
+require 'os'
+
+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
+
+      def initialize(params)
+        @container_name = params[:container_name]
+        @no_vnc_port = params[:no_vnc_port]
+        @device_name = params[:device_name]
+        @docker_image = params[:docker_image]
+        @timeout = params[:container_timeout]
+        @sdk_path = params[:sdk_path]
+        @port_factor = params[:port_factor].to_i
+        @maximal_run_time = params[:maximal_run_time]
+        @sleep_interval = 5
+        @container = nil
+        @adb_path = adb_path
+        @is_running_on_emulator = params[:is_running_on_emulator]
+        @pre_action = params[:pre_action]
+        @docker_registry_login = params[:docker_registry_login]
+        @pull_latest_image = params[:pull_latest_image]
+      end
+
+      # Setting up the container:
+      # 1. Checks if ports are already allocated and kill the ones that do
+      # 2. Checks if Container we want to create already exist. If it does, restart it and check that the ports are correct
+      # 3. Creates container if there wasn't one already created or the created one has incorrect ports
+      # 4. Finally, waits until container is up and running (Healthy) using timeout specified in params
+      def setup_container
+        assign_unique_vnc_port if port_factor && is_running_on_emulator
+
+        if container_available?
+          @container.stop
+          @container.delete(force: true)
+        end
+
+        handle_ports_allocation if is_running_on_emulator
+
+        execute_pre_action if @pre_action
+
+        pull_from_registry if @pull_latest_image
+
+        # Make sure that network bridge for the current container is not already used
+        disconnect_network_bridge if container_name
+
+        create_container
+
+        begin
+          wait_for_healthy_container false
+          check_emulator_connection if is_running_on_emulator
+        rescue StandardError
+          UI.important("Will retry checking for a healthy docker container after #{sleep_interval} seconds")
+          @container.stop
+          @container.delete(force: true)
+          sleep @sleep_interval
+          create_container
+          wait_for_healthy_container
+          check_emulator_connection if is_running_on_emulator
+        end
+      end
+
+      # Stops and remove container
+      def clean_container
+        @container.stop
+        @container.delete(force: true)
+      end
+
+      # Executes commands inside docker container
+      def docker_exec(command)
+        Actions.sh("docker exec -i #{container_name} bash -l -c \"#{command}\"")
+      end
+
+      private
+
+      # Sets path to adb
+      def adb_path
+        "#{@sdk_path}/platform-tools/adb"
+      end
+
+      # 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")
+        UI.success("Port: #{@no_vnc_port} was chosen for VNC")
+        UI.success("Link to VNC: http://#{@host_ip_address}:#{@no_vnc_port}")
+      end
+
+      # Restarts adb on the separate port and checks if created emulator is connected
+      def check_emulator_connection
+        UI.success('Checking if emulator is connected to ADB.')
+
+        if emulator_is_healthy?
+          UI.success('Emulator connected successfully')
+        else
+          raise "Something went wrong. Newly created device couldn't connect to the adb"
+        end
+
+        disable_animations
+        increase_logcat_storage
+      end
+
+      def emulator_is_healthy?
+        list_devices = docker_exec('adb devices')
+        list_devices.include? "\tdevice"
+      end
+
+      # Creates new container using params
+      def create_container
+        UI.important("Creating container: #{container_name}")
+        print_cpu_load
+        begin
+          container = create_container_call
+          @container_name = container unless container_name
+        rescue StandardError
+          UI.important("Something went wrong while creating: #{container_name}, will retry in #{@sleep_interval} seconds")
+          print_cpu_load
+          `docker stop #{container_name}` if container_name
+          `docker rm #{container_name}` if container_name
+          sleep @sleep_interval
+          container = create_container_call
+          @container_name = container unless container_name
+        end
+        get_container_instance(container)
+      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
+        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
+
+        docker_name = if container_name
+                        "--name #{container_name}"
+                      else
+                        ''
+                      end
+
+        emulator_args = is_running_on_emulator ? "-p #{no_vnc_port}:6080 -e DEVICE='#{device_name}'" : ''
+
+        # 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")
+        output = Actions.sh("docker run -v $PWD:/root/tests --privileged -t -d #{emulator_args} #{docker_name} #{docker_image}").chomp
+        output.split("\n").last
+      end
+
+      def execute_pre_action
+        Actions.sh(@pre_action)
+      end
+
+      # Pull the docker images before creating a container
+      def pull_from_registry
+        docker_image_name = docker_image.gsub(':latest', '')
+        Actions.sh(@docker_registry_login) if @docker_registry_login
+        Actions.sh("docker pull #{docker_image_name}")
+      end
+
+      # Checks that chosen ports are not already allocated. If they are, it will stop the allocated container
+      def handle_ports_allocation
+        vnc_allocated_container = container_of_allocated_port(no_vnc_port)
+        if vnc_allocated_container
+          UI.important("Port: #{no_vnc_port} was already allocated. Stopping Container.")
+          vnc_allocated_container.stop
+        end
+
+        if ports_open?('0.0.0.0', [@no_vnc_port])
+          UI.important('Something went wrong. One of the required ports is still busy')
+          sleep @sleep_interval
+          `docker stop #{container_name}` if container_name
+          `docker rm #{container_name}` if container_name
+        end
+      end
+
+      # Gets container instance of allocated port
+      def container_of_allocated_port(port)
+        Docker::Container.all.each do |container|
+          public_ports = container.info['Ports'].map { |public_port| public_port['PublicPort'] }
+          return container if public_ports.include? port
+        end
+        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
+            @container = container
+            return true
+          end
+        end
+        false
+      end
+
+      # Checks if container status is 'healthy'
+      def container_is_healthy?
+        if @container.json['State']['Health']
+          @container.json['State']['Health']['Status'] == 'healthy'
+        else
+          @container.json['State']['Status'] == 'running'
+        end
+      end
+
+      # Waits until container is healthy using specified timeout
+      def wait_for_healthy_container(will_exit = true)
+        UI.important('Waiting for Container to be in the Healthy state.')
+
+        number_of_tries = timeout / sleep_interval
+        number_of_tries.times do
+          sleep sleep_interval / 2
+          if container_is_healthy?
+            UI.success('Your container is ready to work')
+            return true
+          end
+          UI.important("Container status: #{@container.json['State']['Status']}")
+          sleep sleep_interval
+        end
+        UI.important("The Container failed to load after '#{timeout}' seconds timeout. Reason: '#{@container.json['State']['Status']}'")
+        # 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 if will_exit
+        raise 'Fail'
+      end
+
+      # Checks if port is already open
+      def ports_open?(ip, ports)
+        raise "'ports' should be an array" unless ports.is_a? Array
+        ports.each do |port|
+          begin
+            Timeout.timeout(1) do
+              begin
+                s = TCPSocket.new(ip, port)
+                s.close
+                return true
+              rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+              end
+            end
+          rescue Timeout::Error
+          end
+        end
+        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
+
+      # Disables animation for faster and stable testing
+      def disable_animations
+        docker_exec('adb shell settings put global window_animation_scale 0.0')
+        docker_exec('adb shell settings put global transition_animation_scale 0.0')
+        docker_exec('adb shell settings put global animator_duration_scale 0.0')
+      end
+
+      # Increases logcat storage
+      def increase_logcat_storage
+        docker_exec('adb logcat -G 16m')
+      end
+
+      def disconnect_network_bridge
+        `docker network disconnect -f bridge #{container_name}`
+      rescue StandardError
+        # Do nothing if the network bridge is already gone
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Mango
+    VERSION = '1.0.0'.freeze
+  end
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-mango
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Serghei Moret, Daniel Hartwich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.66.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.66.2
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.58.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.58.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: serghei.moret@xing.com, hartwich.daniel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/mango.rb
+- lib/fastlane/plugin/mango/actions/run_dockerized_task_action.rb
+- lib/fastlane/plugin/mango/helper/mango_helper.rb
+- lib/fastlane/plugin/mango/version.rb
+homepage: https://github.com/xing/mango
+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.7.7
+signing_key: 
+specification_version: 4
+summary: This plugin Android tasks on docker images
+test_files: []