fastlane 2.69.0.beta.20171212010004 → 2.69.0

data/fastlane/lib/fastlane/lane_manager.rb

@@ -1,5 +1,7 @@
+require_relative 'lane_manager_base.rb'
+
 module Fastlane
-  class LaneManager
+  class LaneManager < LaneManagerBase
     # @param platform The name of the platform to execute
     # @param lane_name The name of the lane to execute
     # @param parameters [Hash] The parameters passed from the command line to the lane
@@ -171,73 +173,5 @@ module Fastlane
         UI.user_error! "Run `fastlane` the next time you need to build, test or release your app 🚀"
       end
     end
-
-    # @param env_cl_param [String] an optional list of dotenv environment names separated by commas, without space
-    def self.load_dot_env(env_cl_param)
-      base_path = find_dotenv_directory
-
-      return unless base_path
-
-      load_dot_envs_from(env_cl_param, base_path)
-    end
-
-    # finds the first directory of [fastlane, its parent] containing dotenv files
-    def self.find_dotenv_directory
-      path = FastlaneCore::FastlaneFolder.path
-      search_paths = [path]
-      search_paths << path + "/.." unless path.nil?
-      search_paths.compact!
-      search_paths.find do |dir|
-        Dir.glob(File.join(dir, '*.env*'), File::FNM_DOTMATCH).count > 0
-      end
-    end
-
-    # loads the dotenvs. First the .env and .env.default and
-    # then override with all speficied extra environments
-    def self.load_dot_envs_from(env_cl_param, base_path)
-      require 'dotenv'
-
-      # Making sure the default '.env' and '.env.default' get loaded
-      env_file = File.join(base_path, '.env')
-      env_default_file = File.join(base_path, '.env.default')
-      Dotenv.load(env_file, env_default_file)
-
-      return unless env_cl_param
-
-      Actions.lane_context[Actions::SharedValues::ENVIRONMENT] = env_cl_param
-
-      # multiple envs?
-      envs = env_cl_param.split(",")
-
-      # Loads .env file for the environment(s) passed in through options
-      envs.each do |env|
-        env_file = File.join(base_path, ".env.#{env}")
-        UI.success "Loading from '#{env_file}'"
-        Dotenv.overload(env_file)
-      end
-    end
-
-    private_class_method :find_dotenv_directory, :load_dot_envs_from
-
-    def self.print_lane_context
-      return if Actions.lane_context.empty?
-
-      if FastlaneCore::Globals.verbose?
-        UI.important 'Lane Context:'.yellow
-        UI.message Actions.lane_context
-        return
-      end
-
-      # Print a nice table unless in FastlaneCore::Globals.verbose? mode
-      rows = Actions.lane_context.collect do |key, content|
-        [key, content.to_s]
-      end
-
-      require 'terminal-table'
-      puts Terminal::Table.new({
-        title: "Lane Context".yellow,
-        rows: FastlaneCore::PrintTable.transform_output(rows)
-      })
-    end
   end
 end

data/fastlane/lib/fastlane/lane_manager_base.rb

@@ -0,0 +1,124 @@
+module Fastlane
+  # Base class for all LaneManager classes
+  # Takes care of all common things like printing the lane description tables and loading .env files
+  class LaneManagerBase
+    def self.skip_docs?
+      Helper.test? || FastlaneCore::Env.truthy?("FASTLANE_SKIP_DOCS")
+    end
+
+    # All the finishing up that needs to be done
+    def self.finish_fastlane(ff, duration, error)
+      # Sometimes we don't have a fastfile because we're using Fastfile.swift
+      unless ff.nil?
+        ff.runner.did_finish
+      end
+
+      # Finished with all the lanes
+      Fastlane::JUnitGenerator.generate(Fastlane::Actions.executed_actions)
+      print_table(Fastlane::Actions.executed_actions)
+
+      Fastlane::PluginUpdateManager.show_update_status
+
+      if error
+        UI.error 'fastlane finished with errors'
+        raise error
+      elsif duration > 5
+        UI.success "fastlane.tools just saved you #{duration} minutes! 🎉"
+      else
+        UI.success 'fastlane.tools finished successfully 🎉'
+      end
+    end
+
+    # Print a table as summary of the executed actions
+    def self.print_table(actions)
+      return if actions.count == 0
+
+      require 'terminal-table'
+
+      rows = []
+      actions.each_with_index do |current, i|
+        is_error_step = !current[:error].to_s.empty?
+
+        name = current[:name][0..60]
+        name = name.red if is_error_step
+        index = i + 1
+        index = "💥" if is_error_step
+        rows << [index, name, current[:time].to_i]
+      end
+
+      puts ""
+      puts Terminal::Table.new(
+        title: "fastlane summary".green,
+        headings: ["Step", "Action", "Time (in s)"],
+        rows: FastlaneCore::PrintTable.transform_output(rows)
+      )
+      puts ""
+    end
+
+    # @param env_cl_param [String] an optional list of dotenv environment names separated by commas, without space
+    def self.load_dot_env(env_cl_param)
+      base_path = find_dotenv_directory
+
+      return unless base_path
+
+      load_dot_envs_from(env_cl_param, base_path)
+    end
+
+    # finds the first directory of [fastlane, its parent] containing dotenv files
+    def self.find_dotenv_directory
+      path = FastlaneCore::FastlaneFolder.path
+      search_paths = [path]
+      search_paths << path + "/.." unless path.nil?
+      search_paths.compact!
+      search_paths.find do |dir|
+        Dir.glob(File.join(dir, '*.env*'), File::FNM_DOTMATCH).count > 0
+      end
+    end
+
+    # loads the dotenvs. First the .env and .env.default and
+    # then override with all speficied extra environments
+    def self.load_dot_envs_from(env_cl_param, base_path)
+      require 'dotenv'
+
+      # Making sure the default '.env' and '.env.default' get loaded
+      env_file = File.join(base_path, '.env')
+      env_default_file = File.join(base_path, '.env.default')
+      Dotenv.load(env_file, env_default_file)
+
+      return unless env_cl_param
+
+      Actions.lane_context[Actions::SharedValues::ENVIRONMENT] = env_cl_param
+
+      # multiple envs?
+      envs = env_cl_param.split(",")
+
+      # Loads .env file for the environment(s) passed in through options
+      envs.each do |env|
+        env_file = File.join(base_path, ".env.#{env}")
+        UI.success "Loading from '#{env_file}'"
+        Dotenv.overload(env_file)
+      end
+    end
+
+    def self.print_lane_context
+      return if Actions.lane_context.empty?
+
+      if FastlaneCore::Globals.verbose?
+        UI.important 'Lane Context:'.yellow
+        UI.message Actions.lane_context
+        return
+      end
+
+      # Print a nice table unless in FastlaneCore::Globals.verbose? mode
+      rows = Actions.lane_context.collect do |key, content|
+        [key, content.to_s]
+      end
+
+      require 'terminal-table'
+      puts Terminal::Table.new({
+        title: "Lane Context".yellow,
+        rows: FastlaneCore::PrintTable.transform_output(rows)
+      })
+    end
+  end
+end

data/fastlane/lib/fastlane/runner.rb

@@ -212,7 +212,7 @@ module Fastlane
       end
     end
 
-    def execute_action(method_sym, class_ref, arguments, custom_dir: nil, from_action: false)
+    def execute_action(method_sym, class_ref, arguments, custom_dir: nil, from_action: false, configuration_language: nil)
       if custom_dir.nil?
         custom_dir ||= "." if Helper.test?
         custom_dir ||= ".."
@@ -221,7 +221,7 @@ module Fastlane
       verify_supported_os(method_sym, class_ref)
 
       begin
-        launch_context = FastlaneCore::ActionLaunchContext.context_for_action_name(method_sym.to_s, args: ARGV)
+        launch_context = FastlaneCore::ActionLaunchContext.context_for_action_name(method_sym.to_s, configuration_language: configuration_language, args: ARGV)
         FastlaneCore.session.action_launched(launch_context: launch_context)
 
         Dir.chdir(custom_dir) do # go up from the fastlane folder, to the project folder

data/fastlane/lib/fastlane/server/command.rb

@@ -0,0 +1,70 @@
+require 'json'
+
+module Fastlane
+  class Argument
+    def initialize(json: nil)
+      @name = json['name']
+      @value = json['value']
+      @value_type = json['value_type']
+    end
+
+    def is_named
+      return @name.to_s.length > 0
+    end
+
+    def inspect
+      if is_named
+        return "named argument: #{name}, value: #{value}, type: #{value_type}"
+      else
+        return "unnamed argument value: #{value}, type: #{value_type}"
+      end
+    end
+
+    attr_reader :name
+    attr_reader :value
+    attr_reader :value_type
+  end
+
+  class Command
+    def initialize(json: nil)
+      command_json = JSON.parse(json)
+      @method_name = command_json['methodName']
+      @class_name = command_json['className']
+      @command_id = command_json['commandID']
+
+      args_json = command_json['args'] ||= []
+      @args = args_json.map do |arg|
+        Argument.new(json: arg)
+      end
+    end
+
+    def target_class
+      unless class_name
+        return nil
+      end
+
+      return Fastlane::Actions.const_get(class_name)
+    end
+
+    def is_class_method_command
+      return class_name.to_s.length > 0
+    end
+
+    attr_reader :command_id # always present
+    attr_reader :args # always present
+    attr_reader :method_name # always present
+    attr_reader :class_name # only present when executing a class-method
+  end
+
+  class CommandReturn
+    attr_reader :return_value
+    attr_reader :return_value_type
+    attr_reader :closure_argument_value
+
+    def initialize(return_value: nil, return_value_type: nil, closure_argument_value: nil)
+      @return_value = return_value
+      @closure_argument_value = closure_argument_value
+      @return_value_type = return_value_type
+    end
+  end
+end

data/fastlane/lib/fastlane/server/command_executor.rb

@@ -0,0 +1,9 @@
+require 'fastlane/server/command.rb'
+
+module Fastlane
+  class CommandExecutor
+    def execute(command: nil, target_object: nil)
+      not_implemented(__method__)
+    end
+  end
+end

data/fastlane/lib/fastlane/server/socket_server.rb

@@ -0,0 +1,212 @@
+require 'fastlane/server/command.rb'
+require 'fastlane/server/command_executor.rb'
+require 'socket'
+require 'json'
+
+module Fastlane
+  class SocketServer
+    attr_accessor :command_executor
+    attr_accessor :return_value_processor
+
+    def initialize(
+      command_executor: nil,
+      return_value_processor: nil,
+      connection_timeout: 5,
+      stay_alive: false
+    )
+      if return_value_processor.nil?
+        return_value_processor = JSONReturnValueProcessor.new
+      end
+
+      @command_executor = command_executor
+      @return_value_processor = return_value_processor
+      @connection_timeout = connection_timeout.to_i
+      @stay_alive = stay_alive
+    end
+
+    # This is the public API, don't call anything else
+    def start
+      while listen
+        # Loop for-ev-er
+      end
+    end
+
+    private
+
+    def receive_and_process_commands
+      # We'll break out of the infinite loop somehow, either error or 'done' message
+      ended_loop_due_to_error = true
+
+      loop do # No idea how many commands are coming, so we loop until an error or the done command is sent
+        str = nil
+
+        begin
+          str = @client.recv(1_048_576) # 1024 * 1024
+        rescue Errno::ECONNRESET => e
+          UI.verbose(e)
+          break
+        end
+
+        if str == 'done'
+          time = Time.new
+          UI.verbose("[#{time.usec}]: received done signal, shutting down")
+          ended_loop_due_to_error = false
+          break
+        end
+        response_json = process_command(command_json: str)
+
+        time = Time.new
+        UI.verbose("[#{time.usec}]: sending #{response_json}")
+        begin
+          @client.puts(response_json) # Send some json to the client
+        rescue Errno::EPIPE => e
+          UI.verbose(e)
+          break
+        end
+      end
+
+      return handle_disconnect(error: ended_loop_due_to_error)
+    end
+
+    def listen
+      @server = TCPServer.open('localhost', 2000) # Socket to listen on port 2000
+      UI.message("Waiting for #{@connection_timeout} seconds for a connection from FastlaneRunner")
+
+      # set thread local to ready so we can check it
+      Thread.current[:ready] = true
+      @client = nil
+      begin
+        Timeout.timeout(@connection_timeout) do
+          @client = @server.accept # Wait for a client to connect
+        end
+      rescue Timeout::Error
+        UI.user_error!("fastlane failed to receive a connection from the FastlaneRunner binary after #{@connection_timeout} seconds, shutting down")
+      rescue StandardError => e
+        UI.user_error!("Something went wrong while waiting for a connection from the FastlaneRunner binary, shutting down\n#{e}")
+      end
+      UI.message("Client connected")
+
+      receive_and_process_commands
+    end
+
+    def handle_disconnect(error: false)
+      UI.important("Client disconnected, or a pipe broke") if error
+      if @stay_alive
+        UI.important("stay_alive is set to true, restarting server")
+        # clean up before restart
+        @client.close
+        @client = nil
+
+        @server.close
+        @server = nil
+        return true # Restart server
+      end
+      return false # Don't restart server
+    end
+
+    def process_command(command_json: nil)
+      time = Time.new
+      UI.verbose("[#{time.usec}]: received command:#{command_json}")
+      return execute_command(command_json: command_json)
+    end
+
+    def execute_command(command_json: nil)
+      command = Command.new(json: command_json)
+      command_return = @command_executor.execute(command: command, target_object: nil)
+      ## probably need to just return Strings, or ready_for_next with object isn't String
+      return_object = command_return.return_value
+      return_value_type = command_return.return_value_type
+      closure_arg = command_return.closure_argument_value
+
+      return_object = return_value_processor.prepare_object(
+        return_value: return_object,
+        return_value_type: return_value_type
+      )
+
+      if closure_arg.nil?
+        closure_arg = closure_arg.to_s
+      else
+        closure_arg = return_value_processor.prepare_object(
+          return_value: closure_arg,
+          return_value_type: :string # always assume string for closure error_callback
+        )
+        closure_arg = ', "closure_argument_value": ' + closure_arg
+      end
+
+      return '{"payload":{"status":"ready_for_next", "return_object":' + return_object + closure_arg + '}}'
+    rescue StandardError => e
+      exception_array = []
+      exception_array << "#{e.class}:"
+      exception_array << e.backtrace
+
+      while e.respond_to?("cause") && (e = e.cause)
+        exception_array << "cause: #{e.class}"
+        exception_array << backtrace
+      end
+      return "{\"payload\":{\"status\":\"failure\",\"failure_information\":#{exception_array.flatten}}}"
+    end
+  end
+
+  class JSONReturnValueProcessor
+    def prepare_object(return_value: nil, return_value_type: nil)
+      case return_value_type
+      when nil
+        UI.verbose("return_value_type is nil value: #{return_value}")
+        return process_value_as_string(return_value: return_value)
+      when :string
+        return process_value_as_string(return_value: return_value)
+      when :int
+        return process_value_as_int(return_value: return_value)
+      when :bool
+        return process_value_as_bool(return_value: return_value)
+      when :array_of_strings
+        return process_value_as_array_of_strings(return_value: return_value)
+      when :hash_of_strings
+        return process_value_as_hash_of_strings(return_value: return_value)
+      else
+        UI.verbose("Unknown return type defined: #{return_value_type} for value: #{return_value}")
+        return process_value_as_string(return_value: return_value)
+      end
+    end
+
+    def process_value_as_string(return_value: nil)
+      if return_value.nil?
+        return_value = ""
+      end
+
+      return JSON.generate(return_value.to_s)
+    end
+
+    def process_value_as_array_of_strings(return_value: nil)
+      if return_value.nil?
+        return_value = []
+      end
+
+      return JSON.generate(return_value)
+    end
+
+    def process_value_as_hash_of_strings(return_value: nil)
+      if return_value.nil?
+        return_value = {}
+      end
+
+      return JSON.generate(return_value)
+    end
+
+    def process_value_as_bool(return_value: nil)
+      if return_value.nil?
+        return_value = false
+      end
+
+      return JSON.generate(return_value)
+    end
+
+    def process_value_as_int(return_value: nil)
+      if return_value.nil?
+        return_value = 0
+      end
+
+      return JSON.generate(return_value)
+    end
+  end
+end