fastlane_iac_publish 0.1.0

data/match/lib/match/storage/interface.rb

@@ -0,0 +1,110 @@
+require_relative '../module'
+
+module Match
+  module Storage
+    class Interface
+      MATCH_VERSION_FILE_NAME = "match_version.txt"
+      # The working directory in which we download all the profiles
+      # and decrypt/encrypt them
+      attr_accessor :working_directory
+
+      # To make debugging easier, we have a custom exception here
+      def working_directory
+        if @working_directory.nil?
+          raise "`working_directory` for the current storage provider is `nil` as the `#download` method was never called"
+        end
+        return @working_directory
+      end
+
+      # Call this method after creating a new object to configure
+      # the given Storage object. This method will take
+      # different paramters depending on specific class being used
+      def configure
+        not_implemented(__method__)
+      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
+        not_implemented(__method__)
+      end
+
+      # Returns a short string describing + identifing the current
+      # storage backend. This will be printed when nuking a storage
+      def human_readable_description
+        not_implemented(__method__)
+      end
+
+      # Call this method after locally modifying the files
+      # This will commit the changes and push it back to the
+      # given remote server
+      # This method is blocking, meaning it might take multiple
+      # seconds or longer to run
+      # @parameter files_to_commit [Array] Array to paths to files
+      #   that should be committed to the storage provider
+      # @parameter custom_message: [String] Custom change message
+      #           that's optional, is used for commit title
+      def save_changes!(files_to_commit: nil, files_to_delete: nil, custom_message: nil)
+        # Custom init to `[]` in case `nil` is passed
+        files_to_commit ||= []
+        files_to_delete ||= []
+
+        Dir.chdir(File.expand_path(self.working_directory)) do
+          if files_to_commit.count > 0 # everything that isn't `match nuke`
+            UI.user_error!("You can't provide both `files_to_delete` and `files_to_commit` right now") if files_to_delete.count > 0
+
+            if !File.exist?(MATCH_VERSION_FILE_NAME) || File.read(MATCH_VERSION_FILE_NAME) != Fastlane::VERSION.to_s
+              files_to_commit << MATCH_VERSION_FILE_NAME
+              File.write(MATCH_VERSION_FILE_NAME, Fastlane::VERSION) # stored unencrypted
+            end
+
+            template = File.read("#{Match::ROOT}/lib/assets/READMETemplate.md")
+            readme_path = "README.md"
+            if (!File.exist?(readme_path) || File.read(readme_path) != template) && !self.skip_docs
+              files_to_commit << readme_path
+              File.write(readme_path, template)
+            end
+
+            self.upload_files(files_to_upload: files_to_commit, custom_message: custom_message)
+            UI.message("Finished uploading files to #{self.human_readable_description}")
+          elsif files_to_delete.count > 0
+            self.delete_files(files_to_delete: files_to_delete, custom_message: custom_message)
+            UI.message("Finished deleting files from #{self.human_readable_description}")
+          else
+            UI.user_error!("Neither `files_to_commit` nor `files_to_delete` were provided to the `save_changes!` method call")
+          end
+        end
+        self.clear_changes
+      end
+
+      def upload_files(files_to_upload: [], custom_message: nil)
+        not_implemented(__method__)
+      end
+
+      def delete_files(files_to_delete: [], custom_message: nil)
+        not_implemented(__method__)
+      end
+
+      def skip_docs
+        not_implemented(__method__)
+      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)
+        not_implemented(__method__)
+      end
+
+      # Call this method to reset any changes made locally to the files
+      def clear_changes
+        return unless @working_directory
+
+        FileUtils.rm_rf(self.working_directory)
+        self.working_directory = nil
+      end
+    end
+  end
+end

data/match/lib/match/table_printer.rb

@@ -0,0 +1,51 @@
+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"
+      }.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,75 @@
+require 'fastlane_core/keychain_importer'
+require 'openssl'
+require_relative 'module'
+
+module Match
+  class Utils
+    def self.import(item_path, keychain, password: "")
+      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.get_cert_info(cer_certificate_path)
+      cert = OpenSSL::X509::Certificate.new(File.binread(cer_certificate_path))
+
+      # 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/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.rb

@@ -0,0 +1,4 @@
+require_relative 'pem/manager'
+require_relative 'pem/options'
+
+require_relative 'pem/module'

data/pem/lib/pem/commands_generator.rb

@@ -0,0 +1,46 @@
+require 'commander'
+
+require 'fastlane/version'
+require 'fastlane_core/configuration/configuration'
+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, :compact
+
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+
+      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,112 @@
+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
+          UI.message("Existing 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]}"
+        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 = OpenSSL::PKCS12.create(PEM.config[:p12_password], certificate_type, pkey, x509_certificate)
+          File.write(p12_cert_path, p12.to_der)
+          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[:development]
+          Spaceship.certificate.development_push
+        elsif PEM.config[:website_push]
+          Spaceship.certificate.website_push
+        else
+          Spaceship.certificate.production_push
+        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

data/pem/lib/pem/options.rb

@@ -0,0 +1,103 @@
+require 'fastlane_core/configuration/config_item'
+require 'credentials_manager/appfile_config'
+
+require_relative 'module'
+
+module PEM
+  class Options
+    def self.available_options
+      user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+      user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+      [
+        FastlaneCore::ConfigItem.new(key: :development,
+                                     env_name: "PEM_DEVELOPMENT",
+                                     description: "Renew the development push certificate instead of the production one",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :website_push,
+                                     env_name: "PEM_WEBSITE_PUSH",
+                                     description: "Create a Website Push certificate",
+                                     is_string: false,
+                                     conflicting_options: [:development],
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :generate_p12,
+                                     env_name: "PEM_GENERATE_P12_FILE",
+                                     description: "Generate a p12 file additionally to a PEM file",
+                                     is_string: false,
+                                     default_value: true),
+        FastlaneCore::ConfigItem.new(key: :active_days_limit,
+                                     env_name: "PEM_ACTIVE_DAYS_LIMIT",
+                                     description: "If the current certificate is active for less than this number of days, generate a new one",
+                                     default_value: 30,
+                                     is_string: false,
+                                     type: Integer,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Value of active_days_limit must be a positive integer or left blank") unless value.kind_of?(Integer) && value > 0
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :force,
+                                     env_name: "PEM_FORCE",
+                                     description: "Create a new push certificate, even if the current one is active for 30 (or PEM_ACTIVE_DAYS_LIMIT) more days",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :save_private_key,
+                                     short_option: "-s",
+                                     env_name: "PEM_SAVE_PRIVATEKEY",
+                                     description: "Set to save the private RSA key",
+                                     is_string: false,
+                                     default_value: true),
+        FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                     short_option: "-a",
+                                     env_name: "PEM_APP_IDENTIFIER",
+                                     description: "The bundle identifier of your app",
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "PEM_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     default_value: user,
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :team_id,
+                                     short_option: "-b",
+                                     env_name: "PEM_TEAM_ID",
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                     default_value_dynamic: true,
+                                     description: "The ID of your Developer Portal team if you're in multiple teams",
+                                     optional: 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: "PEM_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),
+        FastlaneCore::ConfigItem.new(key: :p12_password,
+                                     short_option: "-p",
+                                     env_name: "PEM_P12_PASSWORD",
+                                     sensitive: true,
+                                     description: "The password that is used for your p12 file",
+                                     default_value: ""),
+        FastlaneCore::ConfigItem.new(key: :pem_name,
+                                     short_option: "-o",
+                                     env_name: "PEM_FILE_NAME",
+                                     description: "The file name of the generated .pem file",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :output_path,
+                                     short_option: "-e",
+                                     env_name: "PEM_OUTPUT_PATH",
+                                     description: "The path to a directory in which all certificates and private keys should be stored",
+                                     default_value: ".")
+      ]
+    end
+  end
+end