fastlane-plugin-appcenter 1.8.1 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3383c94635e8212980d620bf95d5e61eca5a3bbacfeea4875e8128884670d66
-  data.tar.gz: 12d16a1669fb1f2c0239d3d0e5feba0e7a076d48c109047ba474b7e59672be5f
+  metadata.gz: 89d582118585c4f375abd0b893ad9648180e33d19308d20c881aea0262356a82
+  data.tar.gz: 57a447973defb5be52cee9ed03a9d635e442cc30b523152b23d0754b63638c14
 SHA512:
-  metadata.gz: 1b8e7acb6b7dc353a0aa443e9d0737b08a634f88e8f311cd78be834d38ceb23d15e81038d8cfba88aca7e09be3f83431fb2681829b969c3f074fe21601b67fdb
-  data.tar.gz: 0f143cb13db8034eca974c0c7a4a6c773c1a9faa3b11c29cf9419397957124f331bfa642ecaad475c4fa6cd41d5d11a53145035de16157b10e239c39573683bd
+  metadata.gz: 3c9c355551542046daffa8383aee7521d9185b76cc4351e494e6645de638a982af60812bb14982ef171707716dce5761d87e98dd9455a2548bde66d3157237db
+  data.tar.gz: c9a7690e05d9251cae36125ab72669bf11733b2fbf25c8d0f15544fe741b9f09e525d924524eb4daccc7056bdd290c06bc68df5f6a72d64558fc225fb4597544

data/README.md

@@ -119,7 +119,7 @@ Here is the list of all existing parameters:
 | `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 |
 | `strict` <br/> `APPCENTER_STRICT_MODE` | Strict mode, set to 'true' to fail early in case a potential error was detected |
 

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)
@@ -186,14 +203,29 @@ module Fastlane
         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
 
-          if uploaded
-            release_id = uploaded['release_id']
+          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 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}")
 
@@ -323,7 +355,6 @@ module Fastlane
           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
@@ -603,7 +634,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),
 

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
@@ -22,7 +37,6 @@ module Fastlane
         if ENV['APPCENTER_ENV']&.upcase == 'INT'
           default_api_url = "https://api-gateway-core-integration.dev.avalanch.es"
         end
-
         options = {
           url: upload_url || default_api_url
         }
@@ -48,13 +62,11 @@ 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}/release_uploads"
+        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(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
@@ -62,7 +74,6 @@ module Fastlane
         end
 
         UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
-
         case response.status
         when 200...300
           response.body
@@ -229,50 +240,141 @@ module Fastlane
         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)
-
-        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)
+      # 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 #{upload_url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST #{set_metadata_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.body = options
         end
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
 
+        case response.status
+        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
+
+      # 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']
+        response = connection.post do |req|
+          req.options.timeout = timeout
+          req.headers['internal-request-source'] = "fastlane"
+        end
         UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
 
         case response.status
         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.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
 
-        url = "v0.1/apps/#{owner_name}/#{app_name}/release_uploads/#{upload_id}"
+        url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases/#{upload_id}"
         body = {
-          status: status
+          upload_status: status,
+          id: upload_id
         }
 
         UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
@@ -331,6 +433,40 @@ 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']
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
+
+          UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+          case response.status
+          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

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Appcenter
-    VERSION = "1.8.1"
+    VERSION = "1.9.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-appcenter
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.9.0
 platform: ruby
 authors:
 - Microsoft Corporation
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-23 00:00:00.000000000 Z
+date: 2020-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -155,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Fastlane plugin for App Center