fastlane_pricing_fix 2.212.1

data/match/lib/match/storage/s3_storage.rb

@@ -0,0 +1,205 @@
+require 'fastlane_core/command_executor'
+require 'fastlane_core/configuration/configuration'
+require 'fastlane/helper/s3_client_helper'
+
+require_relative '../options'
+require_relative '../module'
+require_relative '../spaceship_ensure'
+require_relative './interface'
+
+module Match
+  module Storage
+    # Store the code signing identities on AWS S3
+    class S3Storage < Interface
+      attr_reader :s3_bucket
+      attr_reader :s3_region
+      attr_reader :s3_client
+      attr_reader :s3_object_prefix
+      attr_reader :readonly
+      attr_reader :username
+      attr_reader :team_id
+      attr_reader :team_name
+      attr_reader :api_key_path
+      attr_reader :api_key
+
+      def self.configure(params)
+        s3_region = params[:s3_region]
+        s3_access_key = params[:s3_access_key]
+        s3_secret_access_key = params[:s3_secret_access_key]
+        s3_bucket = params[:s3_bucket]
+        s3_object_prefix = params[:s3_object_prefix]
+
+        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 S3 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(
+          s3_region: s3_region,
+          s3_access_key: s3_access_key,
+          s3_secret_access_key: s3_secret_access_key,
+          s3_bucket: s3_bucket,
+          s3_object_prefix: s3_object_prefix,
+          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(s3_region: nil,
+                     s3_access_key: nil,
+                     s3_secret_access_key: nil,
+                     s3_bucket: nil,
+                     s3_object_prefix: nil,
+                     readonly: nil,
+                     username: nil,
+                     team_id: nil,
+                     team_name: nil,
+                     api_key_path: nil,
+                     api_key: nil)
+        @s3_bucket = s3_bucket
+        @s3_region = s3_region
+        @s3_client = Fastlane::Helper::S3ClientHelper.new(access_key: s3_access_key, secret_access_key: s3_secret_access_key, region: s3_region)
+        @s3_object_prefix = s3_object_prefix.to_s
+        @readonly = readonly
+        @username = username
+        @team_id = team_id
+        @team_name = team_name
+        @api_key_path = api_key_path
+        @api_key = api_key
+      end
+
+      # To make debugging easier, we have a custom exception here
+      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
+
+      # Call this method for the initial clone/download of the
+      # user's certificates & profiles
+      # As part of this method, the `self.working_directory` attribute
+      # will be set
+      def download
+        # Check if we already have a functional working_directory
+        return if @working_directory && Dir.exist?(@working_directory)
+
+        # No existing working directory, creating a new one now
+        self.working_directory = Dir.mktmpdir
+
+        s3_client.find_bucket!(s3_bucket).objects(prefix: s3_object_prefix).each do |object|
+          file_path = strip_s3_object_prefix(object.key) # :s3_object_prefix:team_id/path/to/file
+
+          # strip s3_prefix from file_path
+          download_path = File.join(self.working_directory, file_path)
+
+          FileUtils.mkdir_p(File.expand_path("..", download_path))
+          UI.verbose("Downloading file from S3 '#{file_path}' on bucket #{self.s3_bucket}")
+
+          object.download_file(download_path)
+        end
+        UI.verbose("Successfully downloaded files from S3 to #{self.working_directory}")
+      end
+
+      # Returns a short string describing + identifing the current
+      # storage backend. This will be printed when nuking a storage
+      def human_readable_description
+        return "S3 Bucket [#{s3_bucket}] on region #{s3_region}"
+      end
+
+      def upload_files(files_to_upload: [], custom_message: nil)
+        # `files_to_upload` is an array of files that need to be uploaded to S3
+        # 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 |file_name|
+          # Go from
+          #   "/var/folders/px/bz2kts9n69g8crgv4jpjh6b40000gn/T/d20181026-96528-1av4gge/:team_id/profiles/development/Development_me.mobileprovision"
+          # to
+          #   ":s3_object_prefix:team_id/profiles/development/Development_me.mobileprovision"
+          #
+          target_path = s3_object_path(file_name)
+          UI.verbose("Uploading '#{target_path}' to S3 Storage...")
+
+          body = File.read(file_name)
+          acl = 'private'
+          s3_url = s3_client.upload_file(s3_bucket, target_path, body, acl)
+          UI.verbose("Uploaded '#{s3_url}' to S3 Storage.")
+        end
+      end
+
+      def delete_files(files_to_delete: [], custom_message: nil)
+        files_to_delete.each do |file_name|
+          target_path = s3_object_path(file_name)
+          UI.verbose("Deleting '#{target_path}' from S3 Storage...")
+          s3_client.delete_file(s3_bucket, 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
+
+      # Implement this for the `fastlane match init` command
+      # This method must return the content of the Matchfile
+      # that should be generated
+      def generate_matchfile_content(template: nil)
+        return "s3_bucket(\"#{self.s3_bucket}\")"
+      end
+
+      private
+
+      def s3_object_path(file_name)
+        sanitized = sanitize_file_name(file_name)
+        return sanitized if sanitized.start_with?(s3_object_prefix)
+
+        s3_object_prefix + sanitized
+      end
+
+      def strip_s3_object_prefix(object_path)
+        object_path.gsub(/^#{s3_object_prefix}/, "")
+      end
+
+      def sanitize_file_name(file_name)
+        file_name.gsub(self.working_directory + "/", "")
+      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, api_token)
+          return spaceship.team_id
+        end
+      end
+
+      def api_token
+        api_token = Spaceship::ConnectAPI::Token.from(hash: self.api_key, filepath: self.api_key_path)
+        api_token ||= Spaceship::ConnectAPI.token
+        return api_token
+      end
+    end
+  end
+end

data/match/lib/match/storage.rb

@@ -0,0 +1,50 @@
+require_relative 'storage/interface'
+require_relative 'storage/git_storage'
+require_relative 'storage/google_cloud_storage'
+require_relative 'storage/s3_storage'
+require_relative 'storage/gitlab_secure_files'
+
+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)
+          },
+          "gitlab_secure_files" => lambda { |params|
+            return Storage::GitLabSecureFiles.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/table_printer.rb

@@ -0,0 +1,52 @@
+require 'terminal-table'
+
+require 'fastlane_core/print_table'
+require_relative 'module'
+require_relative 'utils'
+
+module Match
+  class TablePrinter
+    # logs public key's  name, user, organisation, country, availability dates
+    def self.print_certificate_info(cert_info: nil)
+      params = {
+        rows: cert_info,
+        title: "Installed Certificate".green
+      }
+
+      puts("")
+      puts(Terminal::Table.new(params))
+      puts("")
+    rescue => ex
+      UI.error(ex)
+    end
+
+    def self.print_summary(app_identifier: nil, type: nil, platform: :ios)
+      rows = []
+
+      type = type.to_sym
+
+      rows << ["App Identifier", "", app_identifier]
+      rows << ["Type", "", type]
+      rows << ["Platform", "", platform.to_s]
+
+      {
+        Utils.environment_variable_name(app_identifier: app_identifier, type: type, platform: platform) => "Profile UUID",
+        Utils.environment_variable_name_profile_name(app_identifier: app_identifier, type: type, platform: platform) => "Profile Name",
+        Utils.environment_variable_name_profile_path(app_identifier: app_identifier, type: type, platform: platform) => "Profile Path",
+        Utils.environment_variable_name_team_id(app_identifier: app_identifier, type: type, platform: platform) => "Development Team ID",
+        Utils.environment_variable_name_certificate_name(app_identifier: app_identifier, type: type, platform: platform) => "Certificate Name"
+      }.each do |env_key, name|
+        rows << [name, env_key, ENV[env_key]]
+      end
+
+      params = {}
+      params[:rows] = FastlaneCore::PrintTable.transform_output(rows)
+      params[:title] = "Installed Provisioning Profile".green
+      params[:headings] = ['Parameter', 'Environment Variable', 'Value']
+
+      puts("")
+      puts(Terminal::Table.new(params))
+      puts("")
+    end
+  end
+end

data/match/lib/match/utils.rb

@@ -0,0 +1,88 @@
+require 'fastlane_core/keychain_importer'
+require 'openssl'
+require_relative 'module'
+
+module Match
+  class Utils
+    def self.import(item_path, keychain, password: nil)
+      keychain_path = FastlaneCore::Helper.keychain_path(keychain)
+      FastlaneCore::KeychainImporter.import_file(item_path, keychain_path, keychain_password: password, output: FastlaneCore::Globals.verbose?)
+    end
+
+    # Fill in an environment variable, ready to be used in _xcodebuild_
+    def self.fill_environment(key, value)
+      UI.important("Setting environment variable '#{key}' to '#{value}'") if FastlaneCore::Globals.verbose?
+      ENV[key] = value
+    end
+
+    def self.environment_variable_name(app_identifier: nil, type: nil, platform: :ios)
+      base_environment_variable_name(app_identifier: app_identifier, type: type, platform: platform).join("_")
+    end
+
+    def self.environment_variable_name_team_id(app_identifier: nil, type: nil, platform: :ios)
+      (base_environment_variable_name(app_identifier: app_identifier, type: type, platform: platform) + ["team-id"]).join("_")
+    end
+
+    def self.environment_variable_name_profile_name(app_identifier: nil, type: nil, platform: :ios)
+      (base_environment_variable_name(app_identifier: app_identifier, type: type, platform: platform) + ["profile-name"]).join("_")
+    end
+
+    def self.environment_variable_name_profile_path(app_identifier: nil, type: nil, platform: :ios)
+      (base_environment_variable_name(app_identifier: app_identifier, type: type, platform: platform) + ["profile-path"]).join("_")
+    end
+
+    def self.environment_variable_name_certificate_name(app_identifier: nil, type: nil, platform: :ios)
+      (base_environment_variable_name(app_identifier: app_identifier, type: type, platform: platform) + ["certificate-name"]).join("_")
+    end
+
+    def self.get_cert_info(cer_certificate)
+      # can receive a certificate path or the file data
+      begin
+        if File.exist?(cer_certificate)
+          cer_certificate = File.binread(cer_certificate)
+        end
+      rescue ArgumentError
+        # cert strings have null bytes; suppressing output
+      end
+
+      cert = OpenSSL::X509::Certificate.new(cer_certificate)
+
+      # openssl output:
+      # subject= /UID={User ID}/CN={Certificate Name}/OU={Certificate User}/O={Organisation}/C={Country}
+      cert_info = cert.subject.to_s.gsub(/\s*subject=\s*/, "").tr("/", "\n")
+      out_array = cert_info.split("\n")
+      openssl_keys_to_readable_keys = {
+           'UID' => 'User ID',
+           'CN' => 'Common Name',
+           'OU' => 'Organisation Unit',
+           'O' => 'Organisation',
+           'C' => 'Country',
+           'notBefore' => 'Start Datetime',
+           'notAfter' => 'End Datetime'
+       }
+
+      return out_array.map { |x| x.split(/=+/) if x.include?("=") }
+                      .compact
+                      .map { |k, v| [openssl_keys_to_readable_keys.fetch(k, k), v] }
+                      .push([openssl_keys_to_readable_keys.fetch("notBefore"), cert.not_before])
+                      .push([openssl_keys_to_readable_keys.fetch("notAfter"), cert.not_after])
+    rescue => ex
+      UI.error("get_cert_info: #{ex}")
+      return {}
+    end
+
+    def self.is_cert_valid?(cer_certificate_path)
+      cert = OpenSSL::X509::Certificate.new(File.binread(cer_certificate_path))
+      now = Time.now.utc
+      return (now <=> cert.not_after) == -1
+    end
+
+    def self.base_environment_variable_name(app_identifier: nil, type: nil, platform: :ios)
+      if platform.to_s == :ios.to_s
+        ["sigh", app_identifier, type] # We keep the ios profiles without the platform for backwards compatibility
+      else
+        ["sigh", app_identifier, type, platform.to_s]
+      end
+    end
+  end
+end

data/match/lib/match.rb

@@ -0,0 +1,14 @@
+require_relative 'match/options'
+require_relative 'match/runner'
+require_relative 'match/nuke'
+require_relative 'match/utils'
+require_relative 'match/table_printer'
+require_relative 'match/generator'
+require_relative 'match/setup'
+require_relative 'match/spaceship_ensure'
+require_relative 'match/change_password'
+require_relative 'match/migrate'
+require_relative 'match/importer'
+require_relative 'match/storage'
+require_relative 'match/encryption'
+require_relative 'match/module'

data/pem/README.md

@@ -0,0 +1,17 @@
+<h3 align="center">
+  <a href="https://docs.fastlane.tools/actions/pem/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/fastlane/assets/fastlane.png" width="100" />
+    <br />
+    fastlane
+  </a>
+</h3>
+
+------
+
+<p align="center">
+  <a href="https://docs.fastlane.tools/actions/pem/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/pem/assets/pem.png" height="110">
+  </a>
+</p>
+
+<h3 align="center">The <i>pem</i> docs were moved to <a href='https://docs.fastlane.tools/actions/pem/'>docs.fastlane.tools</a></h3>

data/pem/lib/pem/commands_generator.rb

@@ -0,0 +1,48 @@
+require 'commander'
+
+require 'fastlane/version'
+require 'fastlane_core/configuration/configuration'
+require 'fastlane_core/ui/help_formatter'
+require_relative 'options'
+require_relative 'manager'
+
+HighLine.track_eof = false
+
+module PEM
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :name, 'pem'
+      program :version, Fastlane::VERSION
+      program :description, 'CLI for \'PEM\' - Automatically generate and renew your push notification profiles'
+      program :help, 'Author', 'Felix Krause <pem@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'Documentation', 'https://docs.fastlane.tools/actions/pem/'
+      program :help_formatter, FastlaneCore::HelpFormatter
+
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+      global_option('--env STRING[,STRING2]', String, 'Add environment(s) to use with `dotenv`')
+
+      command :renew do |c|
+        c.syntax = 'fastlane pem renew'
+        c.description = 'Renews the certificate (in case it expired) and shows the path to the generated pem file'
+
+        FastlaneCore::CommanderGenerator.new.generate(PEM::Options.available_options, command: c)
+
+        c.action do |args, options|
+          PEM.config = FastlaneCore::Configuration.create(PEM::Options.available_options, options.__hash__)
+          PEM::Manager.start
+        end
+      end
+
+      default_command(:renew)
+
+      run!
+    end
+  end
+end

data/pem/lib/pem/manager.rb

@@ -0,0 +1,136 @@
+require 'pathname'
+
+require 'spaceship'
+require 'fastlane_core/print_table'
+require_relative 'module'
+
+module PEM
+  # Creates the push profile and stores it in the correct location
+  class Manager
+    class << self
+      def start
+        FastlaneCore::PrintTable.print_values(config: PEM.config, hide_keys: [:new_profile], title: "Summary for PEM #{Fastlane::VERSION}")
+        login
+
+        existing_certificate = certificate_sorted.detect do |c|
+          c.owner_name == PEM.config[:app_identifier]
+        end
+
+        if existing_certificate
+          remaining_days = (existing_certificate.expires - Time.now) / 60 / 60 / 24
+
+          display_platform = ''
+          unless PEM.config[:website_push]
+            display_platform = "#{PEM.config[:platform]} "
+          end
+
+          UI.message("Existing #{display_platform}push notification profile for '#{existing_certificate.owner_name}' is valid for #{remaining_days.round} more days.")
+          if remaining_days > PEM.config[:active_days_limit]
+            if PEM.config[:force]
+              UI.success("You already have an existing push certificate, but a new one will be created since the --force option has been set.")
+            else
+              UI.success("You already have a push certificate, which is active for more than #{PEM.config[:active_days_limit]} more days. No need to create a new one")
+              UI.success("If you still want to create a new one, use the --force option when running PEM.")
+              return false
+            end
+          end
+        end
+
+        return create_certificate
+      end
+
+      def login
+        UI.message("Starting login with user '#{PEM.config[:username]}'")
+        Spaceship.login(PEM.config[:username], nil)
+        Spaceship.client.select_team
+        UI.message("Successfully logged in")
+      end
+
+      def create_certificate
+        UI.important("Creating a new push certificate for app '#{PEM.config[:app_identifier]}'.")
+
+        csr, pkey = Spaceship.certificate.create_certificate_signing_request
+
+        begin
+          cert = certificate.create!(csr: csr, bundle_id: PEM.config[:app_identifier])
+        rescue => ex
+          if ex.to_s.include?("You already have a current")
+            # That's the most common failure probably
+            UI.message(ex.to_s)
+            UI.user_error!("You already have 2 active push profiles for this application/environment. You'll need to revoke an old certificate to make room for a new one")
+          else
+            raise ex
+          end
+        end
+
+        x509_certificate = cert.download
+
+        filename_base = PEM.config[:pem_name] || "#{certificate_type}_#{PEM.config[:app_identifier]}_#{PEM.config[:platform]}"
+        filename_base = File.basename(filename_base, ".pem") # strip off the .pem if it was provided.
+
+        output_path = File.expand_path(PEM.config[:output_path])
+        FileUtils.mkdir_p(output_path)
+
+        if PEM.config[:save_private_key]
+          private_key_path = File.join(output_path, "#{filename_base}.pkey")
+          File.write(private_key_path, pkey.to_pem)
+          UI.message("Private key: ".green + Pathname.new(private_key_path).realpath.to_s)
+        end
+
+        if PEM.config[:generate_p12]
+          p12_cert_path = File.join(output_path, "#{filename_base}.p12")
+          p12_password = PEM.config[:p12_password] == "" ? nil : PEM.config[:p12_password]
+          p12 = OpenSSL::PKCS12.create(p12_password, certificate_type, pkey, x509_certificate)
+          File.write(p12_cert_path, p12.to_der.force_encoding("UTF-8"))
+          UI.message("p12 certificate: ".green + Pathname.new(p12_cert_path).realpath.to_s)
+        end
+
+        x509_cert_path = File.join(output_path, "#{filename_base}.pem")
+        File.write(x509_cert_path, x509_certificate.to_pem + pkey.to_pem)
+        UI.message("PEM: ".green + Pathname.new(x509_cert_path).realpath.to_s)
+        return x509_cert_path
+      end
+
+      def certificate
+        if PEM.config[:website_push]
+          Spaceship.certificate.website_push
+        else
+          platform = PEM.config[:platform]
+          UI.user_error!('platform parameter is unspecified.') unless platform
+
+          case platform
+          when 'ios'
+            if PEM.config[:development]
+              Spaceship.certificate.development_push
+            else
+              Spaceship.certificate.production_push
+            end
+          when 'macos'
+            if PEM.config[:development]
+              Spaceship.certificate.mac_development_push
+            else
+              Spaceship.certificate.mac_production_push
+            end
+          else
+            UI.user_error!("Unsupported platform '#{platform}'. Supported platforms for development and production certificates are 'ios' & 'macos'")
+          end
+
+        end
+      end
+
+      def certificate_type
+        if PEM.config[:development]
+          'development'
+        elsif PEM.config[:website_push]
+          'website'
+        else
+          'production'
+        end
+      end
+
+      def certificate_sorted
+        certificate.all.sort { |x, y| y.expires <=> x.expires }
+      end
+    end
+  end
+end

data/pem/lib/pem/module.rb

@@ -0,0 +1,19 @@
+require 'fastlane_core/helper'
+
+module PEM
+  # Use this to just setup the configuration attribute and set it later somewhere else
+  class << self
+    attr_accessor :config
+  end
+
+  tmp_dir = Dir.tmpdir
+  TMP_FOLDER = "#{tmp_dir}/fastlane/PEM/"
+  FileUtils.mkdir_p(TMP_FOLDER)
+
+  ENV['FASTLANE_TEAM_ID'] ||= ENV["PEM_TEAM_ID"]
+  ENV['DELIVER_USER'] ||= ENV["PEM_USERNAME"]
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+end