fastlane-plugin-appcenter 1.8.0 → 1.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d80a48da7efa15bbdfb68ed3af18b8ed57bac5ecca51d0725b428520a0912608
-  data.tar.gz: 651ed034f616868690bcf677453cb6c8646c9d02692d831284b54f5fe061d4f0
+  metadata.gz: b110405fe9e84494ddb201d8b05738652c29493a2d86cf33a83f63e3843c650f
+  data.tar.gz: a6a582ac374e02c45a5285b6960d8f0da7a44bb7f4375c2d001d25a3aad71d21
 SHA512:
-  metadata.gz: 68027e3171f663771bc1030396874f14c95f118050b8b881a6d61c2a0a9569876f7fe27a8841c32cfcb00c7a8e536fed5c26f47a64f15df78aed5b9683681cc6
-  data.tar.gz: 8d4584eea5879862b0f08a7e074fbee368636de399dd55f76f3e585f4b44717b72f8c2d4dae3da6cbab32b6d19eb6b319a1cb7761850d3399866d167b3972993
+  metadata.gz: 6e30d4329779b399e127a8f31b2828ce307c586ea06539970d3b1ed338db5a1c4222364f269aab763fdb97b18abfc73de67ea0f1928397a3b8dc4b300998afd4
+  data.tar.gz: 766537e348299e02cd0e71f21502884487e76e333941e291229167e4554193d0284faff27eae2f91da24fc9b6a39425bc999e489001cefbd8582485c3f996b78

data/README.md

@@ -31,7 +31,6 @@ To get started, first, [obtain an API token](https://appcenter.ms/settings/apito
 appcenter_fetch_devices(
   api_token: "<appcenter token>",
   owner_name: "<appcenter account name of the owner of the app (username or organization URL name)>",
-  owner_type: "user", # Default is user - set to organization for appcenter organizations
   app_name: "<appcenter app name>",
   destinations: "*", # Default is 'Collaborators', use '*' for all distribution groups
   devices_file: "devices.txt" # Default. If you customize, the extension must be .txt
@@ -53,7 +52,8 @@ appcenter_upload(
 appcenter_fetch_version_number(
   api_token: "<appcenter token>",
   owner_name: "<appcenter account name of the owner of the app (username or organization URL name)>",
-  app_name: "<appcenter app name (as seen in app URL)>"
+  app_name: "<appcenter app name (as seen in app URL)>",
+  version: "a specific version to get the last release for" # optional, don't set this value to get the last upload of all versions
 )
 ```
 
@@ -90,7 +90,6 @@ Here is the list of all existing parameters:
 | Key & Env Var | Description |
 |-----------------|--------------------|
 | `api_token` <br/> `APPCENTER_API_TOKEN` | API Token for App Center |
-| `owner_type` <br/> `APPCENTER_OWNER_TYPE` | Owner type, either 'user' or 'organization' (default: `user`) |
 | `owner_name` <br/> `APPCENTER_OWNER_NAME` | Owner name, as found in the App's URL in App Center |
 | `destinations` <br/> `APPCENTER_DISTRIBUTE_DESTINATIONS` | Comma separated list of distribution group names. Default is 'Collaborators', use '*' for all distribution groups |
 | `devices_file` <br/> `FL_REGISTER_DEVICES_FILE` | File to save the devices list to. Same environment variable as _fastlane_'s `register_devices` action |
@@ -104,7 +103,7 @@ Here is the list of all existing parameters:
 | `owner_name` <br/> `APPCENTER_OWNER_NAME` | Owner name as found in the App's URL in App Center |
 | `app_name` <br/> `APPCENTER_APP_NAME` | App name as found in the App's URL in App Center. If there is no app with such name, you will be prompted to create one |
 | `app_display_name` <br/> `APPCENTER_APP_DISPLAY_NAME` | App display name to use when creating a new app |
-| `app_os` <br/> `APPCENTER_APP_OS` | App OS. Used for new app creation, if app 'app_name' was not found |
+| `app_os` <br/> `APPCENTER_APP_OS` | App OS can be Android, iOS, macOS, Windows, Custom. Used for new app creation, if app 'app_name' was not found |
 | `app_platform` <br/> `APPCENTER_APP_PLATFORM` | App Platform. Used for new app creation, if app 'app_name' was not found |
 | `file` <br/> `APPCENTER_DISTRIBUTE_FILE` | File path to the release build to publish |
 | `upload_build_only` <br/> `APPCENTER_DISTRIBUTE_UPLOAD_BUILD_ONLY` | Flag to upload only the build to App Center. Skips uploading symbols or mapping (default: `false`) |
@@ -116,13 +115,14 @@ Here is the list of all existing parameters:
 | `destination_type` <br/> `APPCENTER_DISTRIBUTE_DESTINATION_TYPE` | Destination type of distribution destination. 'group' and 'store' are supported (default: `group`) |
 | `mandatory_update` <br/> `APPCENTER_DISTRIBUTE_MANDATORY_UPDATE` | Require users to update to this release. Ignored if destination type is 'store' (default: `false`) |
 | `notify_testers` <br/> `APPCENTER_DISTRIBUTE_NOTIFY_TESTERS` | Send email notification about release. Ignored if destination type is 'store' (default: `false`) |
-| `release_notes` <br/> `APPCENTER_DISTRIBUTE_RELEASE_NOTES` | Release notes  (default: `No changelog given`) |
+| `release_notes` <br/> `APPCENTER_DISTRIBUTE_RELEASE_NOTES` | Release notes (default: `No changelog given`) |
 | `should_clip` <br/> `APPCENTER_DISTRIBUTE_RELEASE_NOTES_CLIPPING` | Clip release notes if its length is more then 5000, true by default (default: `true`) |
 | `release_notes_link` <br/> `APPCENTER_DISTRIBUTE_RELEASE_NOTES_LINK` | Additional release notes link |
 | `build_number` <br/> `APPCENTER_DISTRIBUTE_BUILD_NUMBER` | The build number, required for macOS .pkg and .dmg builds, as well as Android ProGuard `mapping.txt` when using `upload_mapping_only` |
 | `version` <br/> `APPCENTER_DISTRIBUTE_VERSION` | The build version, required for .pkg, .dmg, .zip and .msi builds, as well as Android ProGuard `mapping.txt` when using `upload_mapping_only` |
-| `timeout` <br/> `APPCENTER_DISTRIBUTE_TIMEOUT` | Request timeout in seconds |
+| `timeout` <br/> `APPCENTER_DISTRIBUTE_TIMEOUT` | Request timeout in seconds applied to individual HTTP requests. Some commands use multiple HTTP requests, large file uploads are also split in multiple HTTP requests |
 | `dsa_signature` <br/> `APPCENTER_DISTRIBUTE_DSA_SIGNATURE` | DSA signature of the macOS or Windows release for Sparkle update feed |
+| `ed_signature` <br/> `APPCENTER_DISTRIBUTE_ED_SIGNATURE` | EdDSA signature of the macOS or Windows release for Sparkle update feed |
 | `strict` <br/> `APPCENTER_STRICT_MODE` | Strict mode, set to 'true' to fail early in case a potential error was detected |
 
 #### `appcenter_fetch_version_number`
@@ -132,6 +132,7 @@ Here is the list of all existing parameters:
 | `api_token` <br/> `APPCENTER_API_TOKEN` | API Token for App Center |
 | `owner_name` <br/> `APPCENTER_OWNER_NAME` | Owner name, as found in the App's URL in App Center |
 | `app_name` <br/> `APPCENTER_APP_NAME` | App name as found in the App's URL in App Center. If there is no app with such name, you will be prompted to create one |
+| `version` <br/> `APPCENTER_APP_VERSION` | App version to get the last release for instead of the last release of all versions |
 
 ## Example
 
@@ -185,4 +186,4 @@ Check out [SECURITY.md](SECURITY.md) for any security concern with this project.
 
 ## Contact
 
-We're on Twitter as [@vsappcenter](https://www.twitter.com/vsappcenter). Additionally you can reach out to us on the [App Center](https://appcenter.ms/apps) portal by using the blue Intercom button on the bottom right to start a conversation.
+We're on Twitter as [@vsappcenter](https://www.twitter.com/vsappcenter). Additionally you can reach out to us on the [App Center](https://appcenter.ms/apps) portal. Open the "?" menu on the top right corner of screen, then use "Contact support" to file a support ticket. Our support team is there to answer your questions and help you solve your problems. 

data/lib/fastlane/plugin/appcenter/actions/appcenter_fetch_version_number.rb

@@ -1,6 +1,6 @@
-require 'json'
-require 'net/http'
-require 'fastlane_core/ui/ui'
+require "json"
+require "net/http"
+require "fastlane_core/ui/ui"
 
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
@@ -8,38 +8,51 @@ module Fastlane
   module Actions
     class AppcenterFetchVersionNumberAction < Action
       def self.description
-        "Fetches the latest version number of an app from App Center"
+        "Fetches the latest version number of an app or the last build number of a version from App Center"
       end
 
       def self.authors
-        ["jspargo", "ShopKeep"]
+        ["jspargo", "ShopKeep", "Qutaibah"]
       end
 
       def self.run(params)
         api_token = params[:api_token]
         app_name = params[:app_name]
         owner_name = params[:owner_name]
+        version = params[:version]
 
         releases = Helper::AppcenterHelper.fetch_releases(
           api_token: api_token,
           owner_name: owner_name,
-          app_name: app_name
+          app_name: app_name,
         )
 
         UI.abort_with_message!("No versions found for '#{app_name}' owned by #{owner_name}") unless releases
-        sorted_release = releases.sort_by { |release| release['id'] }.reverse!
-        latest_release = sorted_release.first
+
+        sorted_releases = releases
+
+        if version.nil?
+          sorted_releases = releases.sort_by { |release| release["id"] }
+        else
+          sorted_releases = releases.select { |release| release["short_version"] == version }.sort_by { |release| release["id"] }
+        end
+
+        latest_release = sorted_releases.last
 
         if latest_release.nil?
-          UI.user_error!("This app has no releases yet")
+          if version.nil?
+            UI.user_error!("This app has no releases yet")
+            return nil
+          end
+          UI.user_error!("The provided version (#{version}) has no releases yet")
           return nil
         end
 
         return {
-          "id" => latest_release['id'],
-          "version" => latest_release['short_version'],
-          "build_number" => latest_release['version']
-        }
+                 "id" => latest_release["id"],
+                 "version" => latest_release["short_version"],
+                 "build_number" => latest_release["version"],
+               }
       end
 
       def self.available_options
@@ -61,7 +74,13 @@ module Fastlane
                                        description: "Name of the application on App Center",
                                        verify_block: proc do |value|
                                          UI.user_error!("No app name for App Center given, pass using `app_name: 'app name'`") unless value && !value.empty?
-                                       end)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "APPCENTER_APP_VERSION",
+                                       description: "The version to get the latest release for",
+                                       optional: true,
+                                       type: String),
+
         ]
       end
 
@@ -70,11 +89,11 @@ module Fastlane
       end
 
       def self.get_apps(api_token)
-        host_uri = URI.parse('https://api.appcenter.ms')
+        host_uri = URI.parse("https://api.appcenter.ms")
         http = Net::HTTP.new(host_uri.host, host_uri.port)
         http.use_ssl = true
         apps_request = Net::HTTP::Get.new("/v0.1/apps")
-        apps_request['X-API-Token'] = api_token
+        apps_request["X-API-Token"] = api_token
         apps_response = http.request(apps_request)
         return [] unless apps_response.kind_of?(Net::HTTPOK)
         return JSON.parse(apps_response.body)

data/lib/fastlane/plugin/appcenter/actions/appcenter_upload_action.rb

@@ -9,6 +9,23 @@ module Fastlane
           windows: %w(.appx .appxbundle .appxupload .msix .msixbundle .msixupload .zip .msi),
           custom: %w(.zip)
       }
+      CONTENT_TYPES = {
+          apk: "application/vnd.android.package-archive",
+          aab: "application/vnd.android.package-archive",
+          msi: "application/x-msi",
+          plist: "application/xml",
+          aetx: "application/c-x509-ca-cert",
+          cer: "application/pkix-cert",
+          xap: "application/x-silverlight-app",
+          appx: "application/x-appx",
+          appxbundle: "application/x-appxbundle",
+          appxupload: "application/x-appxupload",
+          appxsym: "application/x-appxupload",
+          msix: "application/x-msix",
+          msixbundle: "application/x-msixbundle",
+          msixupload: "application/x-msixupload",
+          msixsym: "application/x-msixupload",
+      }
       ALL_SUPPORTED_EXTENSIONS = SUPPORTED_EXTENSIONS.values.flatten.sort!.uniq!
       STORE_ONLY_EXTENSIONS = %w(.aab)
       STORE_SUPPORTED_EXTENSIONS = %w(.aab .apk .ipa)
@@ -126,6 +143,7 @@ module Fastlane
         build_number = params[:build_number]
         version = params[:version]
         dsa_signature = params[:dsa_signature]
+        ed_signature = params[:ed_signature]
 
         if release_notes.length >= Constants::MAX_RELEASE_NOTES_LENGTH
           unless should_clip
@@ -180,25 +198,40 @@ module Fastlane
             File.delete zip_file
           end
           UI.message("Creating zip archive: #{zip_file}")
-          file = Actions::ZipAction.run(path: file, output_path: zip_file)
+          file = Actions::ZipAction.run(path: file, output_path: zip_file, symlinks: true)
         end
 
         UI.message("Starting release upload...")
         upload_details = Helper::AppcenterHelper.create_release_upload(api_token, owner_name, app_name, release_upload_body)
         if upload_details
-          upload_id = upload_details['upload_id']
-          upload_url = upload_details['upload_url']
+          upload_id = upload_details['id']
+          
+          UI.message("Setting Metadata...")
+          content_type = Constants::CONTENT_TYPES[File.extname(file)&.delete('.').downcase.to_sym] || "application/octet-stream"
+          set_metadata_url = "#{upload_details['upload_domain']}/upload/set_metadata/#{upload_details['package_asset_id']}?file_name=#{File.basename(file)}&file_size=#{File.size(file)}&token=#{upload_details['url_encoded_token']}&content_type=#{content_type}"
+          chunk_size = Helper::AppcenterHelper.set_release_upload_metadata(set_metadata_url, api_token, owner_name, app_name, upload_id, timeout)
+          UI.abort_with_message!("Upload aborted") unless chunk_size
 
           UI.message("Uploading release binary...")
-          uploaded = Helper::AppcenterHelper.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, timeout)
+          upload_url = "#{upload_details['upload_domain']}/upload/upload_chunk/#{upload_details['package_asset_id']}?token=#{upload_details['url_encoded_token']}"
+          uploaded = Helper::AppcenterHelper.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, content_type, chunk_size, timeout)
+          UI.abort_with_message!("Upload aborted") unless uploaded
+
+          UI.message("Finishing release...")
+          finish_url = "#{upload_details['upload_domain']}/upload/finished/#{upload_details['package_asset_id']}?token=#{upload_details['url_encoded_token']}"
+          finished = Helper::AppcenterHelper.finish_release_upload(finish_url, api_token, owner_name, app_name, upload_id, timeout)
+          UI.abort_with_message!("Upload aborted") unless finished
+
+          UI.message("Waiting for release to be ready...")
+          release_status_url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases/#{upload_id}"
+          release_id = Helper::AppcenterHelper.poll_for_release_id(api_token, release_status_url)
 
-          if uploaded
-            release_id = uploaded['release_id']
+          if release_id.is_a? Integer
             release_url = Helper::AppcenterHelper.get_release_url(owner_type, owner_name, app_name, release_id)
             UI.message("Release '#{release_id}' committed: #{release_url}")
 
             release = Helper::AppcenterHelper.update_release(api_token, owner_name, app_name, release_id, release_notes)
-            Helper::AppcenterHelper.update_release_metadata(api_token, owner_name, app_name, release_id, dsa_signature)
+            Helper::AppcenterHelper.update_release_metadata(api_token, owner_name, app_name, release_id, dsa_signature, ed_signature)
 
             destinations_array = []
             if destinations == '*'
@@ -252,10 +285,11 @@ module Fastlane
         app_platform = params[:app_platform]
 
         platforms = {
-          Android: %w[Java React-Native Xamarin],
-          iOS: %w[Objective-C-Swift React-Native Xamarin],
+          Android: %w[Java React-Native Xamarin Unity],
+          iOS: %w[Objective-C-Swift React-Native Xamarin Unity],
           macOS: %w[Objective-C-Swift],
-          Windows: %w[UWP WPF WinForms Unity]
+          Windows: %w[UWP WPF WinForms Unity],
+          Custom: %w[Custom]
         }
 
         begin
@@ -284,6 +318,30 @@ module Fastlane
         end
       end
 
+      def self.add_app_to_distribution_group_if_needed(params)
+        return unless params[:destination_type] == 'group' && params[:owner_type] == 'organization' && params[:destinations] != '*'
+
+        app_distribution_groups = Helper::AppcenterHelper.fetch_distribution_groups(
+          api_token: params[:api_token],
+          owner_name: params[:owner_name],
+          app_name: params[:app_name]
+        )
+
+        group_names = app_distribution_groups.map { |g| g['name'] }
+        destination_names = params[:destinations].split(',').map(&:strip)
+
+        destination_names.each do |destination_name|
+          unless group_names.include? destination_name
+            Helper::AppcenterHelper.add_new_app_to_distribution_group(
+              api_token: params[:api_token],
+              owner_name: params[:owner_name],
+              app_name: params[:app_name],
+              destination_name: destination_name
+            )
+          end
+        end
+      end
+
       def self.run(params)
         values = params.values
         upload_build_only = params[:upload_build_only]
@@ -294,10 +352,10 @@ module Fastlane
 
         # if app found or successfully created
         if self.get_or_create_app(params)
+          self.add_app_to_distribution_group_if_needed(params)
           release = self.run_release_upload(params) unless upload_dsym_only || upload_mapping_only
           params[:version] = release['short_version'] if release
           params[:build_number] = release['version'] if release
-
           self.run_dsym_upload(params) unless upload_mapping_only || upload_build_only
           self.run_mapping_upload(params) unless upload_dsym_only || upload_build_only
         end
@@ -368,7 +426,7 @@ module Fastlane
 
           FastlaneCore::ConfigItem.new(key: :app_os,
                                   env_name: "APPCENTER_APP_OS",
-                               description: "App OS. Used for new app creation, if app 'app_name' was not found",
+                               description: "App OS can be Android, iOS, macOS, Windows, Custom. Used for new app creation, if app 'app_name' was not found",
                                   optional: true,
                                       type: String),
 
@@ -577,7 +635,7 @@ module Fastlane
 
           FastlaneCore::ConfigItem.new(key: :timeout,
                                        env_name: "APPCENTER_DISTRIBUTE_TIMEOUT",
-                                       description: "Request timeout in seconds",
+                                       description: "Request timeout in seconds applied to individual HTTP requests. Some commands use multiple HTTP requests, large file uploads are also split in multiple HTTP requests",
                                        optional: true,
                                        type: Integer),
 
@@ -586,7 +644,13 @@ module Fastlane
                                        description: "DSA signature of the macOS or Windows release for Sparkle update feed",
                                        optional: true,
                                        type: String),
-
+          
+          FastlaneCore::ConfigItem.new(key: :ed_signature,
+                                       env_name: "APPCENTER_DISTRIBUTE_ED_SIGNATURE",
+                                       description: "EdDSA signature of the macOS or Windows release for Sparkle update feed",
+                                       optional: true,
+                                       type: String),
+          
           FastlaneCore::ConfigItem.new(key: :strict,
                                        env_name: "APPCENTER_STRICT_MODE",
                                        description: "Strict mode, set to 'true' to fail early in case a potential error was detected",

data/lib/fastlane/plugin/appcenter/helper/appcenter_helper.rb

@@ -1,7 +1,22 @@
+class File
+  def each_chunk(chunk_size)
+    yield read(chunk_size) until eof?
+  end
+end
+
 module Fastlane
   module Helper
     class AppcenterHelper
 
+      # Time to wait between 2 status polls in seconds
+      RELEASE_UPLOAD_STATUS_POLL_INTERVAL = 1
+
+      # Maximum number of retries for a request
+      MAX_REQUEST_RETRIES = 2
+
+      # Delay between retries in seconds
+      REQUEST_RETRY_INTERVAL = 5
+
       # basic utility method to check file types that App Center will accept,
       # accounting for file types that can and should be zip-compressed
       # before they are uploaded
@@ -18,10 +33,16 @@ module Fastlane
         require 'faraday'
         require 'faraday_middleware'
 
+        default_api_url = "https://api.appcenter.ms"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          default_api_url = "https://api-gateway-core-integration.dev.avalanch.es"
+        end
         options = {
-          url: upload_url || ENV.fetch('APPCENTER_UPLOAD_URL', "https://api.appcenter.ms")
+          url: upload_url || default_api_url
         }
 
+        UI.message("DEBUG: BASE URL #{options[:url]}") if ENV['DEBUG']
+
         Faraday.new(options) do |builder|
           if upload_url
             builder.request :multipart unless dsym
@@ -41,16 +62,29 @@ module Fastlane
       # upload_url
       def self.create_release_upload(api_token, owner_name, app_name, body)
         connection = self.connection
+        url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases"
+        body ||= {}
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body: #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/release_uploads") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = body.nil? && {} || body
+        status, message, response = retry_429_and_error do 
+          response = connection.post(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception creating release upload: #{message}")
+          else
+            UI.error("Retryable error creating release upload #{status}: #{message}")
+          end
+          false
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -59,7 +93,7 @@ module Fastlane
           UI.error("Not found, invalid owner or application name")
           false
         when 500...600
-          UI.crash!("Internal Service Error, please try again later")
+          UI.abort_with_message!("Internal Service Error, please try again later")
         else
           UI.error("Error #{response.status}: #{response.body}")
           false
@@ -74,20 +108,34 @@ module Fastlane
       def self.create_mapping_upload(api_token, owner_name, app_name, file_name, build_number, version)
         connection = self.connection
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            symbol_type: "AndroidProguard",
-            file_name: file_name,
-            build: build_number,
-            version: version,
-          }
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads"
+        body = {
+          symbol_type: "AndroidProguard",
+          file_name: file_name,
+          build: build_number,
+          version: version,
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.post(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception creating mapping upload: #{message}")
+          else
+            UI.error("Retryable error creating mapping upload #{status}: #{message}")
+          end
+          false
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -109,17 +157,31 @@ module Fastlane
       def self.create_dsym_upload(api_token, owner_name, app_name)
         connection = self.connection
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            symbol_type: 'Apple'
-          }
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads"
+        body = {
+          symbol_type: 'Apple'
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.post(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception creating dsym upload: #{message}")
+          else
+            UI.error("Retryable error creating dsym upload #{status}: #{message}")
+          end
+          false
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -137,17 +199,31 @@ module Fastlane
       def self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, status)
         connection = self.connection
 
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads/#{symbol_upload_id}") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "status" => status
-          }
-        end
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads/#{symbol_upload_id}"
+        body = {
+          status: status
+        }
+
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
 
-        case response.status
+        status, message, response = retry_429_and_error do 
+          response = connection.patch(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
+        end
+      
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception updating symbol upload: #{message}")
+          else
+            UI.error("Retryable error updating symbol upload #{status}: #{message}")
+          end
+          false
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -164,84 +240,225 @@ module Fastlane
       def self.upload_symbol(api_token, owner_name, app_name, symbol, symbol_type, symbol_upload_id, upload_url)
         connection = self.connection(upload_url, true)
 
-        response = connection.put do |req|
-          req.headers['x-ms-blob-type'] = "BlockBlob"
-          req.headers['Content-Length'] = File.size(symbol).to_s
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = Faraday::UploadIO.new(symbol, 'application/octet-stream') if symbol && File.exist?(symbol)
-        end
+        UI.message("DEBUG: PUT #{upload_url}") if ENV['DEBUG']
+        UI.message("DEBUG: PUT body <data>\n") if ENV['DEBUG']
+
+        log_type = "dSYM" if symbol_type == "Apple"
+        log_type = "mapping" if symbol_type == "Android"
 
-        logType = "dSYM" if (symbol_type == "Apple")
-        logType = "mapping" if (symbol_type == "Android")
+        status, message, response = retry_429_and_error do 
+          response = connection.put do |req|
+            req.headers['x-ms-blob-type'] = "BlockBlob"
+            req.headers['Content-Length'] = File.size(symbol).to_s
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = Faraday::UploadIO.new(symbol, 'application/octet-stream') if symbol && File.exist?(symbol)
+          end
+        end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception updating symbol upload: #{message}")
+          else
+            UI.error("Retryable error updating symbol upload #{status}: #{message}")
+          end
+          false
         when 200...300
           self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, 'committed')
-          UI.success("#{logType} uploaded")
+          UI.success("#{log_type} uploaded")
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         else
-          UI.error("Error uploading #{logType} #{response.status}: #{response.body}")
+          UI.error("Error uploading #{log_type} #{response.status}: #{response.body}")
           self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, 'aborted')
-          UI.error("#{logType} upload aborted")
+          UI.error("#{log_type} upload aborted")
           false
         end
       end
 
-      # upload binary for specified upload_url
-      # if succeed, then commits the release
-      # otherwise aborts
-      def self.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, timeout)
-        connection = self.connection(upload_url)
+      # sets metadata for new upload in App Center
+      # returns:
+      # chunk size
+      def self.set_release_upload_metadata(set_metadata_url, api_token, owner_name, app_name, upload_id, timeout)
+        connection = self.connection(set_metadata_url)
+
+        UI.message("DEBUG: POST #{set_metadata_url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body <data>\n") if ENV['DEBUG']
 
-        options = {}
-        options[:upload_id] = upload_id
-        # ipa field is used for .apk, .aab and .ipa files
-        options[:ipa] = Faraday::UploadIO.new(file, 'application/octet-stream') if file && File.exist?(file)
+        status, message, response = retry_429_and_error do 
+          response = connection.post do |req|
+            req.options.timeout = timeout
+            req.headers['internal-request-source'] = "fastlane"
+          end
+        end
+
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception releasing upload metadata: #{message}")
+          else
+            UI.error("Retryable error releasing upload metadata #{status}: #{message}")
+          end
+          false
+        when 200...300
+          chunk_size = response.body['chunk_size']
+          unless chunk_size.is_a? Integer
+            UI.error("Set metadata didn't return chunk size: #{response.status}: #{response.body}")
+            false
+          else
+            UI.message("Metadata set")
+            chunk_size
+          end
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+          false
+        else
+          UI.error("Error setting metadata: #{response.status}: #{response.body}")
+          false
+        end
+      end
 
-        response = connection.post do |req|
-          req.options.timeout = timeout
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = options
+      # Verifies a successful upload to App Center
+      # returns:
+      # successful upload response body.
+      def self.finish_release_upload(finish_url, api_token, owner_name, app_name, upload_id, timeout)
+        connection = self.connection(finish_url)
+
+        UI.message("DEBUG: POST #{finish_url}") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.post do |req|
+            req.options.timeout = timeout
+            req.headers['internal-request-source'] = "fastlane"
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception finishing release upload: #{message}")
+          else
+            UI.error("Retryable error finishing release upload #{status}: #{message}")
+          end
+          false
         when 200...300
-          UI.message("Binary uploaded")
-          self.update_release_upload(api_token, owner_name, app_name, upload_id, 'committed')
+          if response.body['error'] == false
+            UI.message("Upload finished")
+            self.update_release_upload(api_token, owner_name, app_name, upload_id, 'uploadFinished')
+          else
+            UI.error("Error finishing upload: #{response.body['message']}")
+            false
+          end
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         else
-          UI.error("Error uploading binary #{response.status}: #{response.body}")
-          self.update_release_upload(api_token, owner_name, app_name, upload_id, 'aborted')
-          UI.error("Release aborted")
+          UI.error("Error finishing upload: #{response.status}: #{response.body}")
           false
         end
       end
 
+      # upload binary for specified upload_url
+      # if succeed, then commits the release
+      # otherwise aborts
+      def self.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, content_type, chunk_size, timeout)
+        block_number = 1
+
+        File.open(file).each_chunk(chunk_size) do |chunk|
+          upload_chunk_url = "#{upload_url}&block_number=#{block_number}"
+          retries = 0
+
+          while retries <= MAX_REQUEST_RETRIES
+            begin
+              connection = self.connection(upload_chunk_url, true)
+
+              UI.message("DEBUG: POST #{upload_chunk_url}") if ENV['DEBUG']
+              UI.message("DEBUG: POST body <data>\n") if ENV['DEBUG']
+              response = connection.post do |req|
+                req.options.timeout = timeout
+                req.headers['internal-request-source'] = "fastlane"
+                req.headers['Content-Length'] = chunk.length.to_s
+                req.headers['Content-Type'] = 'application/octet-stream'
+                req.body = chunk
+              end
+              UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+              status = response.status
+              message = response.body
+            rescue Faraday::Error => e
+
+              # Low level HTTP errors, we will retry them
+              status = 0
+              message = e.message
+            end
+
+            case status
+            when 200...300
+              if response.body['error'] == false
+                UI.message("Chunk uploaded")
+                block_number += 1
+                break
+              else
+                UI.error("Error uploading binary #{response.body['message']}")
+                return false
+              end
+            when 401
+              UI.user_error!("Auth Error, provided invalid token")
+              return false
+            when 400...407, 409...428, 430...499
+              UI.user_error!("Client error: #{response.status}: #{response.body}")
+              return false
+            else
+              if retries < MAX_REQUEST_RETRIES
+                UI.message("DEBUG: Retryable error uploading binary #{status}: #{message}")
+                retries += 1
+                sleep(REQUEST_RETRY_INTERVAL)
+              else
+                UI.error("Error uploading binary #{status}: #{message}")
+                return false
+              end
+            end
+          end
+        end
+        UI.message("Binary uploaded")
+      end
+
       # Commits or aborts the upload process for a release
       def self.update_release_upload(api_token, owner_name, app_name, upload_id, status)
         connection = self.connection
 
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/release_uploads/#{upload_id}") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "status" => status
-          }
+        url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases/#{upload_id}"
+        body = {
+          upload_status: status,
+          id: upload_id
+        }
+
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.patch(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception updating release upload: #{message}")
+          else
+            UI.error("Retryable error updating release upload #{status}: #{message}")
+          end
+          false
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         when 500...600
-          UI.crash!("Internal Service Error, please try again later")
+          UI.abort_with_message!("Internal Service Error, please try again later")
         else
           UI.error("Error #{response.status}: #{response.body}")
           false
@@ -251,15 +468,28 @@ module Fastlane
       # get existing release
       def self.get_release(api_token, owner_name, app_name, release_id)
         connection = self.connection
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
+
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception getting release: #{message}")
+          else
+            UI.error("Retryable error getting release: #{status}: #{message}")
+          end
+          false
         when 200...300
           release = response.body
-          UI.message("DEBUG: #{JSON.pretty_generate(release)}") if ENV['DEBUG']
           release
         when 404
           UI.error("Not found, invalid release url")
@@ -273,19 +503,73 @@ module Fastlane
         end
       end
 
+      # Polls the upload for a release id. When a release is uploaded, we have to check
+      # for a successful extraction before we can continue.
+      # returns:
+      # release_distinct_id
+      def self.poll_for_release_id(api_token, url)
+        connection = self.connection
+
+        while true
+          UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+          status, message, response = retry_429_and_error do 
+            response = connection.get(url) do |req|
+              req.headers['X-API-Token'] = api_token
+              req.headers['internal-request-source'] = "fastlane"
+            end
+          end
+
+          case status
+          when 0, 429
+            if status == 0
+              UI.error("Faraday http exception polling for release id: #{message}")
+            else
+              UI.error("Retryable error polling for release id: #{status}: #{message}")
+            end
+            return false
+          when 200...300
+            case response.body['upload_status']
+            when "readyToBePublished"
+              return response.body['release_distinct_id']
+            when "error"
+              UI.error("Error fetching release: #{response.body['error_details']}")
+              return false
+            else
+              sleep(RELEASE_UPLOAD_STATUS_POLL_INTERVAL)
+            end
+          else
+            UI.error("Error fetching information about release #{response.status}: #{response.body}")
+            return false
+          end
+        end
+      end
+
       # get distribution group or store
       def self.get_destination(api_token, owner_name, app_name, destination_type, destination_name)
         connection = self.connection
 
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}/distribution_#{destination_type}s/#{ERB::Util.url_encode(destination_name)}") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
+        url = "v0.1/apps/#{owner_name}/#{app_name}/distribution_#{destination_type}s/#{ERB::Util.url_encode(destination_name)}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception getting destination: #{message}")
+          else
+            UI.error("Retryable error getting destination: #{status}: #{message}")
+          end
+          false
         when 200...300
           destination = response.body
-          UI.message("DEBUG: received #{destination_type} #{JSON.pretty_generate(destination)}") if ENV['DEBUG']
           destination
         when 404
           UI.error("Not found, invalid distribution #{destination_type} name")
@@ -303,15 +587,30 @@ module Fastlane
       def self.update_release(api_token, owner_name, app_name, release_id, release_notes = '')
         connection = self.connection
 
-        response = connection.put("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            release_notes: release_notes
-          }
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+        body = {
+          release_notes: release_notes
+        }
+
+        UI.message("DEBUG: PUT #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PUT body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.put(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception updating release: #{message}")
+          else
+            UI.error("Retryable error updating release: #{status}: #{message}")
+          end
+          false
         when 200...300
           # get full release info
           release = self.get_release(api_token, owner_name, app_name, release_id)
@@ -319,8 +618,6 @@ module Fastlane
 
           download_url = release['download_url']
 
-          UI.message("DEBUG: #{JSON.pretty_generate(release)}") if ENV['DEBUG']
-
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_DOWNLOAD_LINK] = download_url
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_BUILD_INFORMATION] = release
 
@@ -340,23 +637,42 @@ module Fastlane
       end
 
       # updates release metadata
-      def self.update_release_metadata(api_token, owner_name, app_name, release_id, dsa_signature)
-        return if dsa_signature.to_s == ''
+      def self.update_release_metadata(api_token, owner_name, app_name, release_id, dsa_signature = '', ed_signature = '')
+        return if dsa_signature.to_s == '' && ed_signature.to_s == ''
 
-        release_metadata = {
-          dsa_signature: dsa_signature
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+        body = {
+          metadata: {}
         }
+        
+        if dsa_signature.to_s != ''
+          body[:metadata]["dsa_signature"] = dsa_signature
+        end
+        if ed_signature.to_s != ''
+          body[:metadata]["ed_signature"] = ed_signature
+        end
+
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
 
         connection = self.connection
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            metadata: release_metadata
-          }
+
+        status, message, response = retry_429_and_error do 
+          response = connection.patch(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception updating release metadata: #{message}")
+          else
+            UI.error("Retryable error updating release metadata: #{status}: #{message}")
+          end
+          false
         when 200...300
           UI.message("Release Metadata was successfully updated for release '#{release_id}'")
         when 404
@@ -375,21 +691,35 @@ module Fastlane
       def self.add_to_destination(api_token, owner_name, app_name, release_id, destination_type, destination_id, mandatory_update = false, notify_testers = false)
         connection = self.connection
 
-        UI.message("DEBUG: getting #{release_id}") if ENV['DEBUG']
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}/#{destination_type}s"
+        body = {
+          id: destination_id
+        }
 
-        body = { "id" => destination_id }
         if destination_type == "group"
           body["mandatory_update"] = mandatory_update
           body["notify_testers"] = notify_testers
         end
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}/#{destination_type}s") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = body
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.post(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception adding to destination: #{message}")
+          else
+            UI.error("Retryable error adding to destination: #{status}: #{message}")
+          end
+          false
         when 200...300
           # get full release info
           release = self.get_release(api_token, owner_name, app_name, release_id)
@@ -397,8 +727,6 @@ module Fastlane
 
           download_url = release['download_url']
 
-          UI.message("DEBUG: received release #{JSON.pretty_generate(release)}") if ENV['DEBUG']
-
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_DOWNLOAD_LINK] = download_url
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_BUILD_INFORMATION] = release
 
@@ -421,12 +749,25 @@ module Fastlane
       def self.get_app(api_token, owner_name, app_name)
         connection = self.connection
 
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}") do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
+        url = "v0.1/apps/#{owner_name}/#{app_name}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception getting app: #{message}")
+          else
+            UI.error("Retryable error getting app: #{status}: #{message}")
+          end
+          false
         when 200...300
           UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           true
@@ -446,23 +787,35 @@ module Fastlane
       def self.create_app(api_token, owner_type, owner_name, app_name, app_display_name, os, platform)
         connection = self.connection
 
-        endpoint = owner_type == "user" ? "v0.1/apps" : "v0.1/orgs/#{owner_name}/apps"
+        url = owner_type == "user" ? "v0.1/apps" : "v0.1/orgs/#{owner_name}/apps"
+        body = {
+          display_name: app_display_name,
+          name: app_name,
+          os: os,
+          platform: platform
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
 
-        response = connection.post(endpoint) do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "display_name" => app_display_name,
-            "name" => app_name,
-            "os" => os,
-            "platform" => platform
-          }
+        status, message, response = retry_429_and_error do 
+          response = connection.post(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http exception creating app: #{message}")
+          else
+            UI.error("Retryable error creating app: #{status}: #{message}")
+          end
+          false
         when 200...300
           created = response.body
-          UI.message("DEBUG: #{JSON.pretty_generate(created)}") if ENV['DEBUG']
           UI.success("Created #{os}/#{platform} app with name \"#{created['name']}\" and display name \"#{created['display_name']}\" for #{owner_type} \"#{owner_name}\"")
           true
         when 401
@@ -477,16 +830,26 @@ module Fastlane
       def self.fetch_distribution_groups(api_token:, owner_name:, app_name:)
         connection = self.connection
 
-        endpoint = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups"
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups"
 
-        response = connection.get(endpoint) do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http fetching destribution groups: #{message}")
+          else
+            UI.error("Retryable error fetching destribution groups: #{status}: #{message}")
+          end
+          false
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -503,16 +866,26 @@ module Fastlane
       def self.fetch_devices(api_token:, owner_name:, app_name:, distribution_group:)
         connection = self.connection(nil, false, true)
 
-        endpoint = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups/#{ERB::Util.url_encode(distribution_group)}/devices/download_devices_list"
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups/#{ERB::Util.url_encode(distribution_group)}/devices/download_devices_list"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
 
-        response = connection.get(endpoint) do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
+        status, message, response = retry_429_and_error do 
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
         end
 
-        case response.status
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http fetching devices: #{message}")
+          else
+            UI.error("Retryable error fetching devices: #{status}: #{message}")
+          end
+          false
         when 200...300
-          UI.message("DEBUG: #{response.body.inspect}") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -529,40 +902,129 @@ module Fastlane
       def self.fetch_releases(api_token:, owner_name:, app_name:)
         connection = self.connection(nil, false, true)
 
-        endpoint = "/v0.1/apps/#{owner_name}/#{app_name}/releases"
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/releases"
 
-        response = connection.get(endpoint) do |req|
-          req.headers['X-API-Token'] = api_token
-          req.headers['internal-request-source'] = "fastlane"
-        end
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
 
-        case response.status
-        when 200...300
-          UI.message("DEBUG: #{response.body.inspect}") if ENV['DEBUG']
-          JSON.parse(response.body)
-        when 401
-          UI.user_error!("Auth Error, provided invalid token")
-          false
-        when 404
-          UI.error("Not found, invalid owner or application name")
-          false
-        else
-          UI.error("Error #{response.status}: #{response.body}")
-          false
+        status, message, response = retry_429_and_error do 
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
         end
+
+       case status
+       when 0, 429
+         if status == 0
+           UI.error("Faraday http fetching releases: #{message}")
+         else
+           UI.error("Retryable error fetching releases: #{status}: #{message}")
+         end
+         false
+       when 200...300
+         JSON.parse(response.body)
+       when 401
+         UI.user_error!("Auth Error, provided invalid token")
+         false
+       when 404
+         UI.error("Not found, invalid owner or application name")
+         false
+       else
+         UI.error("Error #{response.status}: #{response.body}")
+         false
+       end
       end
 
-      # Note: This does not support testing environment (INT)
       def self.get_release_url(owner_type, owner_name, app_name, release_id)
         owner_path = owner_type == "user" ? "users/#{owner_name}" : "orgs/#{owner_name}"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          return "https://portal-server-core-integration.dev.avalanch.es/#{owner_path}/apps/#{app_name}/distribute/releases/#{release_id}"
+        end
+
         return "https://appcenter.ms/#{owner_path}/apps/#{app_name}/distribute/releases/#{release_id}"
       end
 
-      # Note: This does not support testing environment (INT)
       def self.get_install_url(owner_type, owner_name, app_name)
         owner_path = owner_type == "user" ? "users/#{owner_name}" : "orgs/#{owner_name}"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          return "https://install.portal-server-core-integration.dev.avalanch.es/#{owner_path}/apps/#{app_name}"
+        end
+
         return "https://install.appcenter.ms/#{owner_path}/apps/#{app_name}"
       end
+
+      # add new created app to existing distribution group
+      def self.add_new_app_to_distribution_group(api_token:, owner_name:, app_name:, destination_name:)
+        url = URI.escape("/v0.1/orgs/#{owner_name}/distribution_groups/#{destination_name}/apps")
+        body = {
+          apps: [
+            { name: app_name }
+          ]
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        status, message, response = retry_429_and_error do 
+          response = connection.post(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+            req.body = body
+          end
+        end
+
+        case status
+        when 0, 429
+          if status == 0
+            UI.error("Faraday http adding to distribution group: #{message}")
+          else
+            UI.error("Retryable error adding to distribution group: #{status}: #{message}")
+          end
+        when 200...300
+          response.body
+          UI.success("Added new app #{app_name} to distribution group #{destination_name}")
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+        when 404
+          UI.error("Not found, invalid distribution group name #{destination_name}")
+        when 409
+          UI.success("App already added to distribution group #{destination_name}")
+        else
+          UI.error("Error adding app to distribution group #{response.status}: #{response.body}")
+        end
+      end
+
+      def self.retry_429_and_error(&block)
+        retries = 0
+        status = 0
+
+        # status == 0   - Faraday error
+        # status == 429 - retryable error code from server
+        while ((status == 0) || (status == 429)) && (retries <= MAX_REQUEST_RETRIES)
+          begin
+            # calling request sending logic
+            response = block.call
+
+            # checking reponse
+            status = response.status
+            message = response.body
+            UI.message("DEBUG: #{status} #{JSON.pretty_generate(message)}\n") if ENV['DEBUG']
+          rescue Faraday::Error => e
+            status = 0
+            message = e.message
+          end
+
+          # Pause before retrying
+          if (status == 0) || (status == 429)
+            sleep(REQUEST_RETRY_INTERVAL)
+          end
+          
+          retries += 1
+        end
+
+        return status, message, response
+      end
+
     end
   end
 end