fastlane_hotfix 2.165.0

data/match/lib/match/setup.rb

@@ -0,0 +1,40 @@
+require_relative 'module'
+require_relative 'storage'
+
+module Match
+  class Setup
+    def run(path, is_swift_fastfile: false)
+      if is_swift_fastfile
+        template = File.read("#{Match::ROOT}/lib/assets/MatchfileTemplate.swift")
+      else
+        template = File.read("#{Match::ROOT}/lib/assets/MatchfileTemplate")
+      end
+
+      storage_mode = UI.select(
+        "fastlane match supports multiple storage modes, please select the one you want to use:",
+        self.storage_options
+      )
+
+      storage = Storage.for_mode(storage_mode, {})
+
+      specific_content = storage.generate_matchfile_content
+      UI.crash!("Looks like `generate_matchfile_content` was `nil` for `#{storage_mode}`") if specific_content.nil?
+      specific_content += "\n\n" if specific_content.length > 0
+      specific_content += "storage_mode(\"#{storage_mode}\")"
+
+      template.gsub!("[[CONTENT]]", specific_content)
+
+      File.write(path, template)
+      UI.success("Successfully created '#{path}'. You can open the file using a code editor.")
+
+      UI.important("You can now run `fastlane match development`, `fastlane match adhoc`, `fastlane match enterprise` and `fastlane match appstore`")
+      UI.message("On the first run for each environment it will create the provisioning profiles and")
+      UI.message("certificates for you. From then on, it will automatically import the existing profiles.")
+      UI.message("For more information visit https://docs.fastlane.tools/actions/match/")
+    end
+
+    def storage_options
+      return ["git", "google_cloud", "s3"]
+    end
+  end
+end

data/match/lib/match/spaceship_ensure.rb

@@ -0,0 +1,97 @@
+require 'spaceship'
+require_relative 'module'
+
+module Match
+  # Ensures the certificate and profiles are also available on App Store Connect
+  class SpaceshipEnsure
+    attr_accessor :team_id
+
+    def initialize(user, team_id, team_name, api_token)
+      UI.message("Verifying that the certificate and profile are still valid on the Dev Portal...")
+
+      if api_token
+        UI.message("Creating authorization token for App Store Connect API")
+        Spaceship::ConnectAPI.token = api_token
+        self.team_id = team_id
+      else
+        # We'll try to manually fetch the password
+        # to tell the user that a password is optional
+        require 'credentials_manager/account_manager'
+
+        keychain_entry = CredentialsManager::AccountManager.new(user: user)
+
+        if keychain_entry.password(ask_if_missing: false).to_s.length == 0
+          UI.important("You can also run `fastlane match` in readonly mode to not require any access to the")
+          UI.important("Developer Portal. This way you only share the keys and credentials")
+          UI.command("fastlane match --readonly")
+          UI.important("More information https://docs.fastlane.tools/actions/match/#access-control")
+        end
+
+        # Prompts select team if multiple teams and none specified
+        Spaceship::ConnectAPI.login(user, use_portal: true, use_tunes: false, portal_team_id: team_id, team_name: team_name)
+        self.team_id = Spaceship::ConnectAPI.client.portal_team_id
+      end
+    end
+
+    # The team ID of the currently logged in team
+    def team_id
+      return @team_id
+    end
+
+    def bundle_identifier_exists(username: nil, app_identifier: nil, platform: nil)
+      found = Spaceship::ConnectAPI::BundleId.find(app_identifier)
+      return if found
+
+      require 'sigh/runner'
+      Sigh::Runner.new.print_produce_command({
+        username: username,
+        app_identifier: app_identifier
+      })
+      UI.error("An app with that bundle ID needs to exist in order to create a provisioning profile for it")
+      UI.error("================================================================")
+      available_apps = Spaceship::ConnectAPI::BundleId.all.collect { |a| "#{a.identifier} (#{a.name})" }
+      UI.message("Available apps:\n- #{available_apps.join("\n- ")}")
+      UI.error("Make sure to run `fastlane match` with the same user and team every time.")
+      UI.user_error!("Couldn't find bundle identifier '#{app_identifier}' for the user '#{username}'")
+    end
+
+    def certificates_exists(username: nil, certificate_ids: [])
+      Spaceship::ConnectAPI::Certificate.all.each do |cert|
+        certificate_ids.delete(cert.id)
+      end
+      return if certificate_ids.empty?
+
+      certificate_ids.each do |certificate_id|
+        UI.error("Certificate '#{certificate_id}' (stored in your storage) is not available on the Developer Portal")
+      end
+      UI.error("for the user #{username}")
+      UI.error("Make sure to use the same user and team every time you run 'match' for this")
+      UI.error("Git repository. This might be caused by revoking the certificate on the Dev Portal")
+      UI.user_error!("To reset the certificates of your Apple account, you can use the `fastlane match nuke` feature, more information on https://docs.fastlane.tools/actions/match/")
+    end
+
+    def profile_exists(username: nil, uuid: nil, platform: nil)
+      # App Store Connect API does not allow filter of profile by platform or uuid (as of 2020-07-30)
+      # Need to fetch all profiles and search for uuid on client side
+      found = Spaceship::ConnectAPI::Profile.all.find do |profile|
+        profile.uuid == uuid
+      end
+
+      unless found
+        UI.error("Provisioning profile '#{uuid}' is not available on the Developer Portal for the user #{username}, fixing this now for you 🔨")
+        return false
+      end
+
+      if found.valid?
+        return found
+      else
+        UI.important("'#{found.name}' is available on the Developer Portal, however it's 'Invalid', fixing this now for you 🔨")
+        # it's easier to just create a new one, than to repair an existing profile
+        # it has the same effects anyway, including a new UUID of the provisioning profile
+        found.delete!
+        # return nil to re-download the new profile in runner.rb
+        return nil
+      end
+    end
+  end
+end

data/match/lib/match/storage.rb

@@ -0,0 +1,46 @@
+require_relative 'storage/interface'
+require_relative 'storage/git_storage'
+require_relative 'storage/google_cloud_storage'
+require_relative 'storage/s3_storage'
+
+module Match
+  module Storage
+    class << self
+      def backends
+        @backends ||= {
+          "git" => lambda { |params|
+            return Storage::GitStorage.configure(params)
+          },
+          "google_cloud" => lambda { |params|
+            return Storage::GoogleCloudStorage.configure(params)
+          },
+          "s3" => lambda { |params|
+            return Storage::S3Storage.configure(params)
+          }
+        }
+      end
+
+      def register_backend(type: nil, storage_class: nil, &configurator)
+        UI.user_error!("No type specified for storage backend") if type.nil?
+
+        normalized_name = type.to_s
+        UI.message("Replacing Match::Encryption backend for type '#{normalized_name}'") if backends.include?(normalized_name)
+
+        if configurator
+          @backends[normalized_name] = configurator
+        elsif storage_class
+          @backends[normalized_name] = ->(params) { return storage_class.configure(params) }
+        else
+          UI.user_error!("Specify either a `storage_class` or a configuration block when registering a storage backend")
+        end
+      end
+
+      def for_mode(storage_mode, params)
+        configurator = backends[storage_mode.to_s]
+        return configurator.call(params) if configurator
+
+        UI.user_error!("No storage backend for storage mode '#{storage_mode}'")
+      end
+    end
+  end
+end

data/match/lib/match/storage/git_storage.rb

@@ -0,0 +1,250 @@
+require 'fastlane_core/command_executor'
+
+require_relative '../module'
+require_relative './interface'
+
+module Match
+  module Storage
+    # Store the code signing identities in a git repo
+    class GitStorage < Interface
+      # User provided values
+      attr_accessor :git_url
+      attr_accessor :shallow_clone
+      attr_accessor :skip_docs
+      attr_accessor :branch
+      attr_accessor :git_full_name
+      attr_accessor :git_user_email
+      attr_accessor :clone_branch_directly
+      attr_accessor :type
+      attr_accessor :platform
+      attr_accessor :git_basic_authorization
+      attr_accessor :git_bearer_authorization
+      attr_accessor :git_private_key
+
+      def self.configure(params)
+        return self.new(
+          type: params[:type].to_s,
+          platform: params[:platform].to_s,
+          git_url: params[:git_url],
+          shallow_clone: params[:shallow_clone],
+          skip_docs: params[:skip_docs],
+          branch: params[:git_branch],
+          git_full_name: params[:git_full_name],
+          git_user_email: params[:git_user_email],
+          clone_branch_directly: params[:clone_branch_directly],
+          git_basic_authorization: params[:git_basic_authorization],
+          git_bearer_authorization: params[:git_bearer_authorization],
+          git_private_key: params[:git_private_key]
+        )
+      end
+
+      def initialize(type: nil,
+                     platform: nil,
+                     git_url: nil,
+                     shallow_clone: nil,
+                     skip_docs: false,
+                     branch: "master",
+                     git_full_name: nil,
+                     git_user_email: nil,
+                     clone_branch_directly: false,
+                     git_basic_authorization: nil,
+                     git_bearer_authorization: nil,
+                     git_private_key: nil)
+        self.git_url = git_url
+        self.shallow_clone = shallow_clone
+        self.skip_docs = skip_docs
+        self.branch = branch
+        self.git_full_name = git_full_name
+        self.git_user_email = git_user_email
+        self.clone_branch_directly = clone_branch_directly
+        self.git_basic_authorization = git_basic_authorization
+        self.git_bearer_authorization = git_bearer_authorization
+        self.git_private_key = git_private_key
+
+        self.type = type if type
+        self.platform = platform if platform
+      end
+
+      def prefixed_working_directory
+        return working_directory
+      end
+
+      def download
+        # Check if we already have a functional working_directory
+        return if @working_directory
+
+        # No existing working directory, creating a new one now
+        self.working_directory = Dir.mktmpdir
+
+        command = "git clone #{self.git_url.shellescape} #{self.working_directory.shellescape}"
+        # HTTP headers are supposed to be be case insensitive but
+        # Bitbucket requires `Authorization: Basic` and `Authorization Bearer` to work
+        # https://github.com/fastlane/fastlane/pull/15928
+        command << " -c http.extraheader='Authorization: Basic #{self.git_basic_authorization}'" unless self.git_basic_authorization.nil?
+        command << " -c http.extraheader='Authorization: Bearer #{self.git_bearer_authorization}'" unless self.git_bearer_authorization.nil?
+
+        if self.shallow_clone
+          command << " --depth 1 --no-single-branch"
+        elsif self.clone_branch_directly
+          command += " -b #{self.branch.shellescape} --single-branch"
+        end
+
+        unless self.git_private_key.nil?
+          if File.file?(self.git_private_key)
+            ssh_add = File.expand_path(self.git_private_key).shellescape.to_s
+          else
+            UI.message("Private key file does not exist, will continue by using it as a raw key.")
+            ssh_add = "- <<< \"#{self.git_private_key}\""
+          end
+          command = "ssh-agent bash -c 'ssh-add #{ssh_add}; #{command}'"
+        end
+
+        UI.message("Cloning remote git repo...")
+        if self.branch && !self.clone_branch_directly
+          UI.message("If cloning the repo takes too long, you can use the `clone_branch_directly` option in match.")
+        end
+
+        begin
+          # GIT_TERMINAL_PROMPT will fail the `git clone` command if user credentials are missing
+          Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                print_all: FastlaneCore::Globals.verbose?,
+                                            print_command: FastlaneCore::Globals.verbose?)
+          end
+        rescue
+          UI.error("Error cloning certificates repo, please make sure you have read access to the repository you want to use")
+          if self.branch && self.clone_branch_directly
+            UI.error("You passed '#{self.branch}' as branch in combination with the `clone_branch_directly` flag. Please remove `clone_branch_directly` flag on the first run for _match_ to create the branch.")
+          end
+          UI.error("Run the following command manually to make sure you're properly authenticated:")
+          UI.command(command)
+          UI.user_error!("Error cloning certificates git repo, please make sure you have access to the repository - see instructions above")
+        end
+
+        add_user_config(self.git_full_name, self.git_user_email)
+
+        unless File.directory?(self.working_directory)
+          UI.user_error!("Error cloning repo, make sure you have access to it '#{self.git_url}'")
+        end
+
+        checkout_branch
+      end
+
+      def human_readable_description
+        "Git Repo [#{self.git_url}]"
+      end
+
+      def delete_files(files_to_delete: [], custom_message: nil)
+        # No specific list given, e.g. this happens on `fastlane match nuke`
+        # We just want to run `git add -A` to commit everything
+        git_push(commands: ["git add -A"], commit_message: custom_message)
+      end
+
+      def upload_files(files_to_upload: [], custom_message: nil)
+        commands = files_to_upload.map do |current_file|
+          "git add #{current_file.shellescape}"
+        end
+
+        git_push(commands: commands, commit_message: custom_message)
+      end
+
+      # Generate the commit message based on the user's parameters
+      def generate_commit_message
+        [
+          "[fastlane]",
+          "Updated",
+          self.type,
+          "and platform",
+          self.platform
+        ].join(" ")
+      end
+
+      def generate_matchfile_content
+        UI.important("Please create a new, private git repository to store the certificates and profiles there")
+        url = UI.input("URL of the Git Repo: ")
+
+        return "git_url(\"#{url}\")"
+      end
+
+      def list_files(file_name: "", file_ext: "")
+        Dir[File.join(working_directory, "**", file_name, "*.#{file_ext}")]
+      end
+
+      private
+
+      # Create and checkout an specific branch in the git repo
+      def checkout_branch
+        return unless self.working_directory
+
+        commands = []
+        if branch_exists?(self.branch)
+          # Checkout the branch if it already exists
+          commands << "git checkout #{self.branch.shellescape}"
+        else
+          # If a new branch is being created, we create it as an 'orphan' to not inherit changes from the master branch.
+          commands << "git checkout --orphan #{self.branch.shellescape}"
+          # We also need to reset the working directory to not transfer any uncommitted changes to the new branch.
+          commands << "git reset --hard"
+        end
+
+        UI.message("Checking out branch #{self.branch}...")
+
+        Dir.chdir(self.working_directory) do
+          commands.each do |command|
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                  print_all: FastlaneCore::Globals.verbose?,
+                                                  print_command: FastlaneCore::Globals.verbose?)
+          end
+        end
+      end
+
+      # Checks if a specific branch exists in the git repo
+      def branch_exists?(branch)
+        return unless self.working_directory
+
+        result = Dir.chdir(self.working_directory) do
+          FastlaneCore::CommandExecutor.execute(command: "git --no-pager branch --list origin/#{branch.shellescape} --no-color -r",
+                                                print_all: FastlaneCore::Globals.verbose?,
+                                                print_command: FastlaneCore::Globals.verbose?)
+        end
+        return !result.empty?
+      end
+
+      def add_user_config(user_name, user_email)
+        # Add git config if needed
+        commands = []
+        commands << "git config user.name \"#{user_name}\"" unless user_name.nil?
+        commands << "git config user.email \"#{user_email}\"" unless user_email.nil?
+
+        return if commands.empty?
+
+        UI.message("Add git user config to local git repo...")
+        Dir.chdir(self.working_directory) do
+          commands.each do |command|
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                  print_all: FastlaneCore::Globals.verbose?,
+                                                  print_command: FastlaneCore::Globals.verbose?)
+          end
+        end
+      end
+
+      def git_push(commands: [], commit_message: nil)
+        commit_message ||= generate_commit_message
+        commands << "git commit -m #{commit_message.shellescape}"
+        commands << "git push origin #{self.branch.shellescape}"
+
+        UI.message("Pushing changes to remote git repo...")
+        Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+          commands.each do |command|
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                print_all: FastlaneCore::Globals.verbose?,
+                                            print_command: FastlaneCore::Globals.verbose?)
+          end
+        end
+      rescue => ex
+        UI.error("Couldn't commit or push changes back to git...")
+        UI.error(ex)
+      end
+    end
+  end
+end

data/match/lib/match/storage/google_cloud_storage.rb

@@ -0,0 +1,382 @@
+require 'fastlane_core/command_executor'
+require 'fastlane_core/configuration/configuration'
+require 'google/cloud/storage'
+
+require_relative '../options'
+require_relative '../module'
+require_relative '../spaceship_ensure'
+require_relative './interface'
+
+module Match
+  module Storage
+    # Store the code signing identities in on Google Cloud Storage
+    class GoogleCloudStorage < Interface
+      DEFAULT_KEYS_FILE_NAME = "gc_keys.json"
+
+      # User provided values
+      attr_reader :type
+      attr_reader :platform
+      attr_reader :bucket_name
+      attr_reader :google_cloud_keys_file
+      attr_reader :google_cloud_project_id
+      attr_reader :readonly
+      attr_reader :username
+      attr_reader :team_id
+      attr_reader :team_name
+      attr_reader :api_key_path
+      attr_reader :api_key
+
+      # Managed values
+      attr_accessor :gc_storage
+
+      def self.configure(params)
+        if params[:git_url].to_s.length > 0
+          UI.important("Looks like you still define a `git_url` somewhere, even though")
+          UI.important("you use Google Cloud Storage. You can remove the `git_url`")
+          UI.important("from your Matchfile and Fastfile")
+          UI.message("The above is just a warning, fastlane will continue as usual now...")
+        end
+
+        return self.new(
+          type: params[:type].to_s,
+          platform: params[:platform].to_s,
+          google_cloud_bucket_name: params[:google_cloud_bucket_name],
+          google_cloud_keys_file: params[:google_cloud_keys_file],
+          google_cloud_project_id: params[:google_cloud_project_id],
+          readonly: params[:readonly],
+          username: params[:username],
+          team_id: params[:team_id],
+          team_name: params[:team_name],
+          api_key_path: params[:api_key_path],
+          api_key: params[:api_key]
+        )
+      end
+
+      def initialize(type: nil,
+                     platform: nil,
+                     google_cloud_bucket_name: nil,
+                     google_cloud_keys_file: nil,
+                     google_cloud_project_id: nil,
+                     readonly: nil,
+                     username: nil,
+                     team_id: nil,
+                     team_name: nil,
+                     api_key_path: nil,
+                     api_key: nil)
+        @type = type if type
+        @platform = platform if platform
+        @google_cloud_project_id = google_cloud_project_id if google_cloud_project_id
+        @bucket_name = google_cloud_bucket_name
+
+        @readonly = readonly
+        @username = username
+        @team_id = team_id
+        @team_name = team_name
+
+        @api_key_path = api_key_path
+        @api_key = api_key
+
+        @google_cloud_keys_file = ensure_keys_file_exists(google_cloud_keys_file, google_cloud_project_id)
+
+        if self.google_cloud_keys_file.to_s.length > 0
+          # Extract the Project ID from the `JSON` file
+          # so the user doesn't have to provide it manually
+          keys_file_content = JSON.parse(File.read(self.google_cloud_keys_file))
+          if google_cloud_project_id.to_s.length > 0 && google_cloud_project_id != keys_file_content["project_id"]
+            UI.important("The google_cloud_keys_file's project ID ('#{keys_file_content['project_id']}') doesn't match the google_cloud_project_id ('#{google_cloud_project_id}'). This may be the wrong keys file.")
+          end
+          @google_cloud_project_id = keys_file_content["project_id"]
+          if self.google_cloud_project_id.to_s.length == 0
+            UI.user_error!("Provided keys file on path #{File.expand_path(self.google_cloud_keys_file)} doesn't include required value for `project_id`")
+          end
+        end
+
+        # Create the Google Cloud Storage client
+        # If the JSON auth file is invalid, this line will
+        # raise an exception
+        begin
+          self.gc_storage = Google::Cloud::Storage.new(
+            credentials: self.google_cloud_keys_file,
+            project_id: self.google_cloud_project_id
+          )
+        rescue => ex
+          UI.error(ex)
+          UI.verbose(ex.backtrace.join("\n"))
+          UI.user_error!("Couldn't log into your Google Cloud account using the provided JSON file at path '#{File.expand_path(self.google_cloud_keys_file)}'")
+        end
+
+        ensure_bucket_is_selected
+        check_bucket_permissions
+      end
+
+      def currently_used_team_id
+        if self.readonly
+          # In readonly mode, we still want to see if the user provided a team_id
+          # see `prefixed_working_directory` comments for more details
+          return self.team_id
+        else
+          UI.user_error!("The `team_id` option is required. fastlane cannot automatically determine portal team id via the App Store Connect API (yet)") if self.team_id.to_s.empty?
+
+          spaceship = SpaceshipEnsure.new(self.username, self.team_id, self.team_name, self.api_token)
+          return spaceship.team_id
+        end
+      end
+
+      def api_token
+        api_token ||= Spaceship::ConnectAPI::Token.create(self.api_key) if self.api_key
+        api_token ||= Spaceship::ConnectAPI::Token.from_json_file(self.api_key_path) if self.api_key_path
+        return api_token
+      end
+
+      def prefixed_working_directory
+        # We fall back to "*", which means certificates and profiles
+        # from all teams that use this bucket would be installed. This is not ideal, but
+        # unless the user provides a `team_id`, we can't know which one to use
+        # This only happens if `readonly` is activated, and no `team_id` was provided
+        @_folder_prefix ||= currently_used_team_id
+        if @_folder_prefix.nil?
+          # We use a `@_folder_prefix` variable, to keep state between multiple calls of this
+          # method, as the value won't change. This way the warning is only printed once
+          UI.important("Looks like you run `match` in `readonly` mode, and didn't provide a `team_id`. This will still work, however it is recommended to provide a `team_id` in your Appfile or Matchfile")
+          @_folder_prefix = "*"
+        end
+        return File.join(working_directory, @_folder_prefix)
+      end
+
+      def download
+        # Check if we already have a functional working_directory
+        return if @working_directory
+
+        # No existing working directory, creating a new one now
+        self.working_directory = Dir.mktmpdir
+
+        bucket.files.each do |current_file|
+          file_path = current_file.name # e.g. "N8X438SEU2/certs/distribution/XD9G7QCACF.cer"
+          download_path = File.join(self.working_directory, file_path)
+
+          FileUtils.mkdir_p(File.expand_path("..", download_path))
+          UI.verbose("Downloading file from Google Cloud Storage '#{file_path}' on bucket #{self.bucket_name}")
+          current_file.download(download_path)
+        end
+        UI.verbose("Successfully downloaded files from GCS to #{self.working_directory}")
+      end
+
+      def delete_files(files_to_delete: [], custom_message: nil)
+        files_to_delete.each do |current_file|
+          target_path = current_file.gsub(self.working_directory + "/", "")
+          file = bucket.file(target_path)
+          UI.message("Deleting '#{target_path}' from Google Cloud Storage bucket '#{self.bucket_name}'...")
+          file.delete
+        end
+      end
+
+      def human_readable_description
+        "Google Cloud Bucket [#{self.google_cloud_project_id}/#{self.bucket_name}]"
+      end
+
+      def upload_files(files_to_upload: [], custom_message: nil)
+        # `files_to_upload` is an array of files that need to be uploaded to Google Cloud
+        # Those doesn't mean they're new, it might just be they're changed
+        # Either way, we'll upload them using the same technique
+
+        files_to_upload.each do |current_file|
+          # Go from
+          #   "/var/folders/px/bz2kts9n69g8crgv4jpjh6b40000gn/T/d20181026-96528-1av4gge/profiles/development/Development_me.mobileprovision"
+          # to
+          #   "profiles/development/Development_me.mobileprovision"
+          #
+
+          # We also have to remove the trailing `/` as Google Cloud doesn't handle it nicely
+          target_path = current_file.gsub(self.working_directory + "/", "")
+          UI.verbose("Uploading '#{target_path}' to Google Cloud Storage...")
+          bucket.create_file(current_file, target_path)
+        end
+      end
+
+      def skip_docs
+        false
+      end
+
+      def list_files(file_name: "", file_ext: "")
+        Dir[File.join(working_directory, self.team_id, "**", file_name, "*.#{file_ext}")]
+      end
+
+      def generate_matchfile_content
+        return "google_cloud_bucket_name(\"#{self.bucket_name}\")"
+      end
+
+      private
+
+      def bucket
+        @_bucket ||= self.gc_storage.bucket(self.bucket_name)
+
+        if @_bucket.nil?
+          UI.user_error!("Couldn't find Google Cloud Storage bucket with name #{self.bucket_name} for the currently used account. Please make sure you have access")
+        end
+
+        return @_bucket
+      end
+
+      ##########################
+      # Setup related methods
+      ##########################
+
+      # This method will make sure the keys file exists
+      # If it's missing, it will help the user set things up
+      def ensure_keys_file_exists(google_cloud_keys_file, google_cloud_project_id)
+        if google_cloud_keys_file && File.exist?(google_cloud_keys_file)
+          return google_cloud_keys_file
+        end
+
+        return DEFAULT_KEYS_FILE_NAME if File.exist?(DEFAULT_KEYS_FILE_NAME)
+
+        fastlane_folder_gc_keys_path = File.join(FastlaneCore::FastlaneFolder.path || Dir.pwd, DEFAULT_KEYS_FILE_NAME)
+        return fastlane_folder_gc_keys_path if File.exist?(fastlane_folder_gc_keys_path)
+
+        if google_cloud_project_id.to_s.length > 0
+          # Check to see if this system has application default keys installed.
+          # These are the default keys that the Google Cloud APIs use when no other keys are specified.
+          # Users with the Google Cloud SDK installed can generate them by running...
+          # `gcloud auth application-default login`
+          # ...and then they'll be automatically available.
+          # The nice thing about these keys is they can be associated with the user's login in GCP
+          # (e.g. my_account@gmail.com), so teams can control access to the certificate bucket
+          # using a mailing list of developer logins instead of generating service accounts
+          # and keys.
+          application_default_keys = nil
+          begin
+            application_default_keys = Google::Auth.get_application_default
+          rescue
+            # This means no application default keys have been installed. That's perfectly OK,
+            # we can continue and ask the user if they want to use a keys file.
+          end
+
+          if application_default_keys && UI.confirm("Do you want to use this system's Google Cloud application default keys?")
+            return nil
+          end
+        end
+
+        # User doesn't seem to have provided a keys file
+        UI.message("Looks like you don't have a Google Cloud #{DEFAULT_KEYS_FILE_NAME.cyan} file yet.")
+        UI.message("If you have one, make sure to put it into the '#{Dir.pwd}' directory and call it '#{DEFAULT_KEYS_FILE_NAME.cyan}'.")
+        unless UI.confirm("Do you want fastlane to help you to create a #{DEFAULT_KEYS_FILE_NAME} file?")
+          UI.user_error!("Process stopped, run fastlane again to start things up again")
+        end
+
+        UI.message("fastlane will help you create a keys file. Start by opening the following website:")
+        UI.message("")
+        UI.message("\t\thttps://console.cloud.google.com".cyan)
+        UI.message("")
+        UI.input("Press [Enter] once you're logged in")
+
+        UI.message("First, switch to the Google Cloud project you want to use.")
+        UI.message("If you don't have one yet, create a new one and switch to it.")
+        UI.message("")
+        UI.message("\t\thttps://console.cloud.google.com/projectcreate".cyan)
+        UI.message("")
+        UI.input("Press [Enter] once you selected the right project")
+
+        UI.message("Next fastlane will show you the steps to create a keys file.")
+        UI.message("For this it might be useful to switch the Google Cloud interface to English.")
+        UI.message("Append " + "&hl=en".cyan + " to the URL and the interface should be in English.")
+        UI.input("Press [Enter] to continue")
+
+        UI.message("Now it's time to generate a new JSON auth file for fastlane to access Google Cloud Storage:")
+        UI.message("")
+        UI.message("\t\t 1. From the side menu choose 'APIs & Services' and then 'Credentials'".cyan)
+        UI.message("\t\t 2. Click 'Create credentials'".cyan)
+        UI.message("\t\t 3. Choose 'Service account key'".cyan)
+        UI.message("\t\t 4. Select 'New service account'".cyan)
+        UI.message("\t\t 5. Enter a name and ID for the service account".cyan)
+        UI.message("\t\t 6. Don't give the service account a role just yet!".cyan)
+        UI.message("\t\t 7. Make sure the key type is set to 'JSON'".cyan)
+        UI.message("\t\t 8. Click 'Create'".cyan)
+        UI.message("")
+        UI.input("Confirm with [Enter] once you created and downloaded the JSON file")
+
+        UI.message("Copy the file to the current directory (#{Dir.pwd})")
+        UI.message("and rename it to `#{DEFAULT_KEYS_FILE_NAME.cyan}`")
+        UI.message("")
+        UI.input("Confirm with [Enter]")
+
+        until File.exist?(DEFAULT_KEYS_FILE_NAME)
+          UI.message("Make sure to place the file in '#{Dir.pwd.cyan}' and name it '#{DEFAULT_KEYS_FILE_NAME.cyan}'")
+          UI.message("")
+          UI.input("Confirm with [Enter]")
+        end
+
+        UI.important("Please never add the #{DEFAULT_KEYS_FILE_NAME.cyan} file in version control.")
+        UI.important("Instead please add the file to your `.gitignore` file")
+        UI.message("")
+        UI.input("Confirm with [Enter]")
+
+        return DEFAULT_KEYS_FILE_NAME
+      end
+
+      def ensure_bucket_is_selected
+        # Skip the instructions if the user provided a bucket name
+        return unless self.bucket_name.to_s.length == 0
+
+        created_bucket = UI.confirm("Did you already create a Google Cloud Storage bucket?")
+        while self.bucket_name.to_s.length == 0
+          unless created_bucket
+            UI.message("Create a bucket at the following URL:")
+            UI.message("")
+            UI.message("\t\thttps://console.cloud.google.com/storage/browser".cyan)
+            UI.message("")
+            UI.message("Make sure to select the right project at the top of the page!")
+            UI.message("")
+            UI.message("\t\t 1. Click 'Create bucket'".cyan)
+            UI.message("\t\t 2. Enter a unique name".cyan)
+            UI.message("\t\t 3. Select a geographic location for your bucket".cyan)
+            UI.message("\t\t 4. Make sure the storage class is set to 'Standard'".cyan)
+            UI.message("\t\t 5. Click 'Create' to create the bucket".cyan)
+            UI.message("")
+            UI.input("Press [Enter] once you created a bucket")
+          end
+          bucket_name = UI.input("Enter the name of your bucket: ")
+
+          # Verify if the bucket exists
+          begin
+            bucket_exists = !self.gc_storage.bucket(bucket_name).nil?
+          rescue Google::Cloud::PermissionDeniedError
+            bucket_exists = true
+          end
+          created_bucket = bucket_exists
+          if bucket_exists
+            @bucket_name = bucket_name
+          else
+            UI.error("It looks like the bucket '#{bucket_name}' doesn't exist. Make sure to create it first.")
+          end
+        end
+      end
+
+      def check_bucket_permissions
+        bucket = nil
+        while bucket.nil?
+          begin
+            bucket = self.gc_storage.bucket(self.bucket_name)
+          rescue Google::Cloud::PermissionDeniedError
+            bucket = nil
+          end
+          return if bucket.nil? == false
+          UI.error("Looks like your Google Cloud account for the project ID '#{self.google_cloud_project_id}' doesn't")
+          UI.error("have access to the storage bucket '#{self.bucket_name}'. Please visit the following URL:")
+          UI.message("")
+          UI.message("\t\thttps://console.cloud.google.com/storage/browser".cyan)
+          UI.message("")
+          UI.message("You need to give your account the correct permissions:")
+          UI.message("")
+          UI.message("\t\t 1. Click on your bucket to open it".cyan)
+          UI.message("\t\t 2. Click 'Permissions'".cyan)
+          UI.message("\t\t 3. Click 'Add members'".cyan)
+          UI.message("\t\t 4. Enter the service account email address".cyan)
+          UI.message("\t\t 5. Set the role to 'Storage Admin'".cyan)
+          UI.message("\t\t 6. Click 'Save'".cyan)
+          UI.message("")
+          UI.input("Confirm with [Enter] once you're finished")
+        end
+      end
+    end
+  end
+end