fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/actions/modify_services.rb

@@ -0,0 +1,173 @@
+module Fastlane
+  module Actions
+    class ModifyServicesAction < Action
+      def self.run(params)
+        require 'produce'
+
+        Produce.config = params
+
+        Dir.chdir(FastlaneCore::FastlaneFolder.path || Dir.pwd) do
+          require 'produce/service'
+          services = params[:services]
+
+          enabled_services = services.select { |_k, v| v == true || (v != false && v.to_s != 'off') }.map { |k, v| [k, v == true || v.to_s == 'on' ? 'on' : v] }.to_h
+          disabled_services = services.select { |_k, v| v == false || v.to_s == 'off' }.map { |k, v| [k, 'off'] }.to_h
+
+          enabled_services_object = self.service_object
+          enabled_services.each do |k, v|
+            enabled_services_object.__hash__[k] = true
+            enabled_services_object.send("#{k}=", v)
+          end
+          Produce::Service.enable(enabled_services_object, nil) unless enabled_services.empty?
+
+          disabled_services_object = self.service_object
+          disabled_services.each do |k, v|
+            disabled_services_object.__hash__[k] = true
+            disabled_services_object.send("#{k}=", v)
+          end
+          Produce::Service.disable(disabled_services_object, nil) unless disabled_services.empty?
+        end
+      end
+
+      def self.service_object
+        service_object = Object.new
+        service_object.class.module_eval { attr_accessor :__hash__ }
+        service_object.__hash__ = {}
+        Produce::DeveloperCenter::ALLOWED_SERVICES.keys.each do |service|
+          name = self.services_mapping[service]
+          service_object.class.module_eval { attr_accessor :"#{name}" }
+        end
+        service_object
+      end
+
+      def self.services_mapping
+        {
+            access_wifi: 'access_wifi',
+            app_group: 'app_group',
+            apple_pay: 'apple_pay',
+            associated_domains: 'associated_domains',
+            auto_fill_credential: 'auto_fill_credential',
+            data_protection: 'data_protection',
+            game_center: 'game_center',
+            health_kit: 'healthkit',
+            home_kit: 'homekit',
+            hotspot: 'hotspot',
+            icloud: 'icloud',
+            in_app_purchase: 'in_app_purchase',
+            inter_app_audio: 'inter_app_audio',
+            multipath: 'multipath',
+            network_extension: 'network_extension',
+            nfc_tag_reading: 'nfc_tag_reading',
+            personal_vpn: 'personal_vpn',
+            passbook: 'passbook',
+            push_notification: 'push_notification',
+            siri_kit: 'sirikit',
+            vpn_configuration: 'vpn_conf',
+            wallet: 'wallet',
+            wireless_accessory: 'wireless_conf'
+        }
+      end
+
+      def self.allowed_services_description
+        return Produce::DeveloperCenter::ALLOWED_SERVICES.map do |k, v|
+          "#{k}: (#{v.join('|')})(:on|:off)(true|false)"
+        end.join(", ")
+      end
+
+      def self.description
+        'Modifies the services of the app created on Developer Portal'
+      end
+
+      def self.details
+        [
+          "The options are the same as `:enable_services` in the [produce action](https://docs.fastlane.tools/actions/produce/#parameters_1)"
+        ].join("\n")
+      end
+
+      def self.available_options
+        require 'produce'
+        user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+        user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       short_option: "-u",
+                                       env_name: "PRODUCE_USERNAME",
+                                       description: "Your Apple ID Username",
+                                       default_value: user,
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                       env_name: "PRODUCE_APP_IDENTIFIER",
+                                       short_option: "-a",
+                                       description: "App Identifier (Bundle ID, e.g. com.krausefx.app)",
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :services,
+                                       display_in_shell: false,
+                                       env_name: "PRODUCE_ENABLE_SERVICES",
+                                       description: "Array with Spaceship App Services (e.g. #{allowed_services_description})",
+                                       is_string: false,
+                                       type: Hash,
+                                       default_value: {},
+                                       verify_block: proc do |value|
+                                         allowed_keys = Produce::DeveloperCenter::ALLOWED_SERVICES.keys
+                                         UI.user_error!("enable_services has to be of type Hash") unless value.kind_of?(Hash)
+                                         value.each do |key, v|
+                                           UI.user_error!("The key: '#{key}' is not supported in `enable_services' - following keys are available: [#{allowed_keys.join(',')}]") unless allowed_keys.include?(key.to_sym)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       short_option: "-b",
+                                       env_name: "PRODUCE_TEAM_ID",
+                                       description: "The ID of your Developer Portal team if you're in multiple teams",
+                                       optional: true,
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         ENV["FASTLANE_TEAM_ID"] = value.to_s
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :team_name,
+                                       short_option: "-l",
+                                       env_name: "PRODUCE_TEAM_NAME",
+                                       description: "The name of your Developer Portal team if you're in multiple teams",
+                                       optional: true,
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_name),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         ENV["FASTLANE_TEAM_NAME"] = value.to_s
+                                       end)
+        ]
+      end
+
+      def self.author
+        "bhimsenpadalkar"
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'modify_services(
+            username: "test.account@gmail.com",
+            app_identifier: "com.someorg.app",
+            services: {
+              push_notification: "on",
+              associated_domains: "off",
+              wallet: :on,
+              apple_pay: :off,
+              data_protection: true,
+              multipath: false
+            })'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/nexus_upload.rb

@@ -0,0 +1,230 @@
+module Fastlane
+  module Actions
+    class NexusUploadAction < Action
+      def self.run(params)
+        command = []
+        command << "curl"
+        command << verbose(params)
+        command += ssl_options(params)
+        command += proxy_options(params)
+        command += upload_options(params)
+        command << upload_url(params)
+
+        Fastlane::Actions.sh(command.join(' '), log: params[:verbose])
+      end
+
+      def self.upload_url(params)
+        url = "#{params[:endpoint]}#{params[:mount_path]}"
+
+        if params[:nexus_version] == 2
+          url << "/service/local/artifact/maven/content"
+        else
+          file_extension = File.extname(params[:file]).shellescape
+
+          url << "/repository/#{params[:repo_id]}"
+          url << "/#{params[:repo_group_id].gsub('.', '/')}"
+          url << "/#{params[:repo_project_name]}"
+          url << "/#{params[:repo_project_version]}"
+          url << "/#{params[:repo_project_name]}-#{params[:repo_project_version]}"
+          url << "-#{params[:repo_classifier]}" if params[:repo_classifier]
+          url << file_extension.to_s
+        end
+
+        url.shellescape
+      end
+
+      def self.verbose(params)
+        params[:verbose] ? "--verbose" : "--silent"
+      end
+
+      def self.upload_options(params)
+        file_path = File.expand_path(params[:file]).shellescape
+        file_extension = file_path.split('.').last.shellescape
+
+        options = []
+        if params[:nexus_version] == 2
+          options << "-F p=zip"
+          options << "-F hasPom=false"
+          options << "-F r=#{params[:repo_id].shellescape}"
+          options << "-F g=#{params[:repo_group_id].shellescape}"
+          options << "-F a=#{params[:repo_project_name].shellescape}"
+          options << "-F v=#{params[:repo_project_version].shellescape}"
+
+          if params[:repo_classifier]
+            options << "-F c=#{params[:repo_classifier].shellescape}"
+          end
+
+          options << "-F e=#{file_extension}"
+          options << "-F file=@#{file_path}"
+        else
+          options << "--upload-file #{file_path}"
+        end
+
+        options << "-u #{params[:username].shellescape}:#{params[:password].shellescape}"
+
+        options
+      end
+
+      def self.ssl_options(params)
+        options = []
+        unless params[:ssl_verify]
+          options << "--insecure"
+        end
+
+        options
+      end
+
+      def self.proxy_options(params)
+        options = []
+        if params[:proxy_address] && params[:proxy_port] && params[:proxy_username] && params[:proxy_password]
+          options << "-x #{params[:proxy_address].shellescape}:#{params[:proxy_port].shellescape}"
+          options << "--proxy-user #{params[:proxy_username].shellescape}:#{params[:proxy_password].shellescape}"
+        end
+
+        options
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Upload a file to [Sonatype Nexus platform](https://www.sonatype.com)"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :file,
+                                       env_name: "FL_NEXUS_FILE",
+                                       description: "File to be uploaded to Nexus",
+                                       optional: false,
+                                       verify_block: proc do |value|
+                                         file_path = File.expand_path(value)
+                                         UI.user_error!("Couldn't find file at path '#{file_path}'") unless File.exist?(file_path)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :repo_id,
+                                       env_name: "FL_NEXUS_REPO_ID",
+                                       description: "Nexus repository id e.g. artefacts",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :repo_group_id,
+                                       env_name: "FL_NEXUS_REPO_GROUP_ID",
+                                       description: "Nexus repository group id e.g. com.company",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :repo_project_name,
+                                       env_name: "FL_NEXUS_REPO_PROJECT_NAME",
+                                       description: "Nexus repository commandect name. Only letters, digits, underscores(_), hyphens(-), and dots(.) are allowed",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :repo_project_version,
+                                       env_name: "FL_NEXUS_REPO_PROJECT_VERSION",
+                                       description: "Nexus repository commandect version",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :repo_classifier,
+                                       env_name: "FL_NEXUS_REPO_CLASSIFIER",
+                                       description: "Nexus repository artifact classifier (optional)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :endpoint,
+                                       env_name: "FL_NEXUS_ENDPOINT",
+                                       description: "Nexus endpoint e.g. http://nexus:8081",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :mount_path,
+                                       env_name: "FL_NEXUS_MOUNT_PATH",
+                                       description: "Nexus mount path (Nexus 3 instances have this configured as empty by default)",
+                                       default_value: "/nexus",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "FL_NEXUS_USERNAME",
+                                       description: "Nexus username",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_NEXUS_PASSWORD",
+                                       description: "Nexus password",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :ssl_verify,
+                                       env_name: "FL_NEXUS_SSL_VERIFY",
+                                       description: "Verify SSL",
+                                       is_string: false,
+                                       default_value: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :nexus_version,
+                                       env_name: "FL_NEXUS_MAJOR_VERSION",
+                                       description: "Nexus major version",
+                                       type: Integer,
+                                       default_value: 2,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         min_version = 2
+                                         max_version = 3
+                                         UI.user_error!("Unsupported version (#{value}) min. supported version: #{min_version}") unless value >= min_version
+                                         UI.user_error!("Unsupported version (#{value}) max. supported version: #{max_version}") unless value <= max_version
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_NEXUS_VERBOSE",
+                                       description: "Make detailed output",
+                                       is_string: false,
+                                       default_value: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy_username,
+                                       env_name: "FL_NEXUS_PROXY_USERNAME",
+                                       description: "Proxy username",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy_password,
+                                       env_name: "FL_NEXUS_PROXY_PASSWORD",
+                                       sensitive: true,
+                                       description: "Proxy password",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy_address,
+                                       env_name: "FL_NEXUS_PROXY_ADDRESS",
+                                       description: "Proxy address",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy_port,
+                                       env_name: "FL_NEXUS_PROXY_PORT",
+                                       description: "Proxy port",
+                                       optional: true)
+        ]
+      end
+
+      def self.authors
+        ["xfreebird", "mdio"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          '# for Nexus 2
+          nexus_upload(
+            file: "/path/to/file.ipa",
+            repo_id: "artefacts",
+            repo_group_id: "com.fastlane",
+            repo_project_name: "ipa",
+            repo_project_version: "1.13",
+            repo_classifier: "dSYM", # Optional
+            endpoint: "http://localhost:8081",
+            username: "admin",
+            password: "admin123"
+          )',
+          '# for Nexus 3
+          nexus_upload(
+            nexus_version: 3,
+            mount_path: "",
+            file: "/path/to/file.ipa",
+            repo_id: "artefacts",
+            repo_group_id: "com.fastlane",
+            repo_project_name: "ipa",
+            repo_project_version: "1.13",
+            repo_classifier: "dSYM", # Optional
+            endpoint: "http://localhost:8081",
+            username: "admin",
+            password: "admin123"
+          )'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/notarize.rb

@@ -0,0 +1,193 @@
+module Fastlane
+  module Actions
+    class NotarizeAction < Action
+      def self.run(params)
+        package_path = params[:package]
+        bundle_id = params[:bundle_id]
+        try_early_stapling = params[:try_early_stapling]
+        print_log = params[:print_log]
+        verbose = params[:verbose]
+
+        # Compress and read bundle identifier only for .app bundle.
+        compressed_package_path = nil
+        if File.extname(package_path) == '.app'
+          compressed_package_path = "#{package_path}.zip"
+          Actions.sh(
+            "ditto -c -k --rsrc --keepParent \"#{package_path}\" \"#{compressed_package_path}\"",
+            log: verbose
+          )
+
+          unless bundle_id
+            info_plist_path = File.join(package_path, 'Contents', 'Info.plist')
+            bundle_id = Actions.sh(
+              "/usr/libexec/PlistBuddy -c \"Print :CFBundleIdentifier\" \"#{info_plist_path}\"",
+              log: verbose
+            ).strip
+          end
+        end
+
+        UI.user_error!('Could not read bundle identifier, provide as a parameter') unless bundle_id
+
+        apple_id_account = CredentialsManager::AccountManager.new(user: params[:username])
+
+        # Add password as a temporary environment variable for altool.
+        # Use app specific password if specified.
+        ENV['FL_NOTARIZE_PASSWORD'] = ENV['FASTLANE_APPLE_APPLICATION_SPECIFIC_PASSWORD'] || apple_id_account.password
+
+        UI.message('Uploading package to notarization service, might take a while')
+
+        notarization_upload_command = "xcrun altool --notarize-app -t osx -f \"#{compressed_package_path || package_path}\" --primary-bundle-id #{bundle_id} -u #{apple_id_account.user} -p @env:FL_NOTARIZE_PASSWORD --output-format xml"
+        notarization_upload_command << " --asc-provider \"#{params[:asc_provider]}\"" if params[:asc_provider]
+
+        notarization_upload_response = Actions.sh(
+          notarization_upload_command,
+          log: verbose
+        )
+
+        FileUtils.rm_rf(compressed_package_path) if compressed_package_path
+
+        notarization_upload_plist = Plist.parse_xml(notarization_upload_response)
+        notarization_request_id = notarization_upload_plist['notarization-upload']['RequestUUID']
+
+        UI.success("Successfully uploaded package to notarization service with request identifier #{notarization_request_id}")
+
+        notarization_info = {}
+        while notarization_info.empty? || (notarization_info['Status'] == 'in progress')
+          if notarization_info.empty?
+            UI.message('Waiting to query request status')
+          elsif try_early_stapling
+            UI.message('Request in progress, trying early staple')
+
+            begin
+              self.staple(package_path, verbose)
+              UI.message('Successfully notarized and early stapled package.')
+
+              return
+            rescue
+              UI.message('Early staple failed, waiting to query again')
+            end
+          end
+
+          sleep(30)
+
+          UI.message('Querying request status')
+
+          # As of July 2020, the request UUID might not be available for polling yet which returns an error code
+          # This is now handled with the error_callback (which prevents an error from being raised)
+          # Catching this error allows for polling to continue until the notarization is complete
+          error = false
+          notarization_info_response = Actions.sh(
+            "xcrun altool --notarization-info #{notarization_request_id} -u #{apple_id_account.user} -p @env:FL_NOTARIZE_PASSWORD --output-format xml",
+            log: verbose,
+            error_callback: lambda { |msg|
+              error = true
+              UI.error("Error polling for notarization info: #{msg}")
+            }
+          )
+
+          unless error
+            notarization_info_plist = Plist.parse_xml(notarization_info_response)
+            notarization_info = notarization_info_plist['notarization-info']
+          end
+        end
+
+        log_url = notarization_info['LogFileURL']
+        ENV['FL_NOTARIZE_LOG_FILE_URL'] = log_url
+        log_suffix = ''
+        if log_url && print_log
+          log_response = Net::HTTP.get(URI(log_url))
+          log_json_object = JSON.parse(log_response)
+          log_suffix = ", with log:\n#{JSON.pretty_generate(log_json_object)}"
+        end
+
+        case notarization_info['Status']
+        when 'success'
+          UI.message('Stapling package')
+
+          self.staple(package_path, verbose)
+
+          UI.success("Successfully notarized and stapled package#{log_suffix}")
+        when 'invalid'
+          UI.user_error!("Could not notarize package with message '#{notarization_info['Status Message']}'#{log_suffix}")
+        else
+          UI.crash!("Could not notarize package with status '#{notarization_info['Status']}'#{log_suffix}")
+        end
+      ensure
+        ENV.delete('FL_NOTARIZE_PASSWORD')
+      end
+
+      def self.staple(package_path, verbose)
+        Actions.sh(
+          "xcrun stapler staple \"#{package_path}\"",
+          log: verbose
+        )
+      end
+
+      def self.description
+        'Notarizes a macOS app'
+      end
+
+      def self.authors
+        ['zeplin']
+      end
+
+      def self.available_options
+        username = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+        username ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+        asc_provider = CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id)
+
+        [
+          FastlaneCore::ConfigItem.new(key: :package,
+                                       env_name: 'FL_NOTARIZE_PACKAGE',
+                                       description: 'Path to package to notarize, e.g. .app bundle or disk image',
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not find package at '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :try_early_stapling,
+                                       env_name: 'FL_NOTARIZE_TRY_EARLY_STAPLING',
+                                       description: 'Whether to try early stapling while the notarization request is in progress',
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :bundle_id,
+                                       env_name: 'FL_NOTARIZE_BUNDLE_ID',
+                                       description: 'Bundle identifier to uniquely identify the package',
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: 'FL_NOTARIZE_USERNAME',
+                                       description: 'Apple ID username',
+                                       default_value: username,
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :asc_provider,
+                                       env_name: 'FL_NOTARIZE_ASC_PROVIDER',
+                                       description: 'Provider short name for accounts associated with multiple providers',
+                                       optional: true,
+                                       default_value: asc_provider),
+          FastlaneCore::ConfigItem.new(key: :print_log,
+                                       env_name: 'FL_NOTARIZE_PRINT_LOG',
+                                       description: 'Whether to print notarization log file, listing issues on failure and warnings on success',
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: 'FL_NOTARIZE_VERBOSE',
+                                       description: 'Whether to log requests',
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :mac
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end