pantograph 0.1.0

data/pantograph/lib/pantograph/server/socket_server.rb

@@ -0,0 +1,232 @@
+require 'pantograph/server/command_executor.rb'
+require 'pantograph/server/command_parser.rb'
+require 'pantograph/server/json_return_value_processor.rb'
+require 'socket'
+require 'json'
+
+module Pantograph
+  class SocketServer
+    COMMAND_EXECUTION_STATE = {
+      ready: :ready,
+      already_shutdown: :already_shutdown,
+      error: :error
+    }
+
+    attr_accessor :command_executor
+    attr_accessor :return_value_processor
+
+    def initialize(
+      command_executor: nil,
+      return_value_processor: nil,
+      connection_timeout: 5,
+      stay_alive: false,
+      port: 2000
+    )
+      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
+      @port = port.to_i
+    end
+
+    # this is the public API, don't call anything else
+    def start
+      listen
+
+      while @stay_alive
+        UI.important("stay_alive is set to true, restarting server")
+        listen
+      end
+    end
+
+    private
+
+    def receive_and_process_commands
+      loop do # no idea how many commands are coming, so we loop until an error or the done command is sent
+        execution_state = COMMAND_EXECUTION_STATE[:ready]
+
+        command_string = nil
+        begin
+          command_string = @client.recv(1_048_576) # 1024 * 1024
+        rescue Errno::ECONNRESET => e
+          UI.verbose(e)
+          execution_state = COMMAND_EXECUTION_STATE[:error]
+        end
+
+        if execution_state == COMMAND_EXECUTION_STATE[:ready]
+          # Ok, all is good, let's see what command we have
+          execution_state = parse_and_execute_command(command_string: command_string)
+        end
+
+        case execution_state
+        when COMMAND_EXECUTION_STATE[:ready]
+          # command executed successfully, let's setup for the next command
+          next
+        when COMMAND_EXECUTION_STATE[:already_shutdown]
+          # we shutdown in response to a command, nothing left to do but exit
+          break
+        when COMMAND_EXECUTION_STATE[:error]
+          # we got an error somewhere, let's shutdown and exit
+          handle_disconnect(error: true, exit_reason: :error)
+          break
+        end
+      end
+    end
+
+    def parse_and_execute_command(command_string: nil)
+      command = CommandParser.parse(json: command_string)
+      case command
+      when ControlCommand
+        return handle_control_command(command)
+      when ActionCommand
+        return handle_action_command(command)
+      end
+
+      # catch all
+      raise "Command #{command} not supported"
+    end
+
+    # we got a server control command from the client to do something like shutdown
+    def handle_control_command(command)
+      exit_reason = nil
+      if command.cancel_signal?
+        UI.verbose("received cancel signal shutting down, reason: #{command.reason}")
+
+        # send an ack to the client to let it know we're shutting down
+        cancel_response = '{"payload":{"status":"cancelled"}}'
+        send_response(cancel_response)
+
+        exit_reason = :cancelled
+      elsif command.done_signal?
+        UI.verbose("received done signal shutting down")
+
+        # client is already in the process of shutting down, no need to ack
+        exit_reason = :done
+      end
+
+      # if the command came in with a user-facing message, display it
+      if command.user_message
+        UI.important(command.user_message)
+      end
+
+      # currently all control commands should trigger a disconnect and shutdown
+      handle_disconnect(error: false, exit_reason: exit_reason)
+      return COMMAND_EXECUTION_STATE[:already_shutdown]
+    end
+
+    # execute and send back response to client
+    def handle_action_command(command)
+      response_json = process_action_command(command: command)
+      return send_response(response_json)
+    end
+
+    # send json back to client
+    def send_response(json)
+      UI.verbose("sending #{json}")
+      begin
+        @client.puts(json) # Send some json to the client
+      rescue Errno::EPIPE => e
+        UI.verbose(e)
+        return COMMAND_EXECUTION_STATE[:error]
+      end
+      return COMMAND_EXECUTION_STATE[:ready]
+    end
+
+    def listen
+      @server = TCPServer.open('localhost', @port) # Socket to listen on port 2000
+      UI.verbose("Waiting for #{@connection_timeout} seconds for a connection from PantographRunner")
+
+      # 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!("pantograph failed to receive a connection from the PantographRunner binary after #{@connection_timeout} seconds, shutting down")
+      rescue StandardError => e
+        UI.user_error!("Something went wrong while waiting for a connection from the PantographRunner binary, shutting down\n#{e}")
+      end
+      UI.verbose("Client connected")
+
+      # this loops forever
+      receive_and_process_commands
+    end
+
+    def handle_disconnect(error: false, exit_reason: :error)
+      Thread.current[:exit_reason] = exit_reason
+
+      UI.important("Client disconnected, a pipe broke, or received malformed data") if exit_reason == :error
+      # clean up
+      @client.close
+      @client = nil
+
+      @server.close
+      @server = nil
+    end
+
+    # record pantograph action command and then execute it
+    def process_action_command(command: nil)
+      UI.verbose("received command:#{command.inspect}")
+      return execute_action_command(command: command)
+    end
+
+    # execute pantograph action command
+    def execute_action_command(command: nil)
+      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
+        )
+      end
+
+      Thread.current[:exception] = nil
+
+      payload = {
+        payload: {
+          status: "ready_for_next",
+          return_object: return_object,
+          closure_argument_value: closure_arg
+        }
+      }
+      return JSON.generate(payload)
+    rescue StandardError => e
+      Thread.current[:exception] = 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 << e.backtrace
+      end
+
+      payload = {
+        payload: {
+          status: "failure",
+          failure_information: exception_array.flatten
+        }
+      }
+      return JSON.generate(payload)
+    end
+  end
+end

data/pantograph/lib/pantograph/server/socket_server_action_command_executor.rb

@@ -0,0 +1,101 @@
+require 'pantograph/server/action_command_return.rb'
+require 'pantograph/server/command_parser.rb'
+require 'pantograph/server/command_executor.rb'
+
+module Pantograph
+  # Handles receiving commands from the socket server, finding the Action to be invoked,
+  # invoking it, and returning any return values
+  class SocketServerActionCommandExecutor < CommandExecutor
+    attr_accessor :runner
+    attr_accessor :actions_requiring_special_handling
+
+    def initialize
+      Pantograph.load_actions
+      @runner = Runner.new
+      @actions_requiring_special_handling = ["sh"].to_set
+    end
+
+    def execute(command: nil, target_object: nil)
+      action_name = command.method_name
+      action_class_ref = class_ref_for_action(named: action_name)
+      parameter_map = {}
+      closure_argument_value = nil
+
+      command.args.each do |arg|
+        arg_value = arg.value
+        if arg.value_type.to_s.to_sym == :string_closure
+          closure = proc { |string_value| closure_argument_value = string_value }
+          arg_value = closure
+        end
+        parameter_map[arg.name.to_sym] = arg_value
+      end
+
+      if @actions_requiring_special_handling.include?(action_name)
+        command_return = run_action_requiring_special_handling(
+          command: command,
+          parameter_map: parameter_map,
+          action_return_type: action_class_ref.return_type
+        )
+        return command_return
+      end
+
+      action_return = run(
+        action_named: action_name,
+        action_class_ref: action_class_ref,
+        parameter_map: parameter_map
+      )
+
+      command_return = ActionCommandReturn.new(
+        return_value: action_return,
+        return_value_type: action_class_ref.return_type,
+        closure_argument_value: closure_argument_value
+      )
+      return command_return
+    end
+
+    def class_ref_for_action(named: nil)
+      class_ref = Actions.action_class_ref(named)
+      unless class_ref
+        if Pantograph::Actions.formerly_bundled_actions.include?(action)
+          # This was a formerly bundled action which is now a plugin.
+          UI.verbose(caller.join("\n"))
+          UI.user_error!("The action '#{action}' is no longer bundled with pantograph. You can install it using `pantograph add_plugin #{action}`")
+        else
+          Pantograph::ActionsList.print_suggestions(action)
+          UI.user_error!("Action '#{action}' not available, run `pantograph actions` to get a full list")
+        end
+      end
+
+      return class_ref
+    end
+
+    def run(action_named: nil, action_class_ref: nil, parameter_map: nil)
+      action_return = runner.execute_action(action_named, action_class_ref, [parameter_map], custom_dir: '.')
+      return action_return
+    end
+
+    # Some actions have special handling in pant_file.rb, that means we can't directly call the action
+    # but we have to use the same logic that is in pant_file.rb instead.
+    # That's where this switch statement comes into play
+    def run_action_requiring_special_handling(command: nil, parameter_map: nil, action_return_type: nil)
+      action_return = nil
+      closure_argument_value = nil # only used if the action uses it
+
+      case command.method_name
+      when "sh"
+        error_callback = proc { |string_value| closure_argument_value = string_value }
+        command_param = parameter_map[:command]
+        log_param = parameter_map[:log]
+        action_return = Pantograph::PantFile.sh(command_param, log: log_param, error_callback: error_callback)
+      end
+
+      command_return = ActionCommandReturn.new(
+        return_value: action_return,
+        return_value_type: action_return_type,
+        closure_argument_value: closure_argument_value
+      )
+
+      return command_return
+    end
+  end
+end

data/pantograph/lib/pantograph/setup/setup.rb

@@ -0,0 +1,290 @@
+require "tty-spinner"
+
+module Pantograph
+  class Setup
+    # :ios or :android
+    attr_accessor :platform
+
+    # Path to the xcodeproj or xcworkspace
+    attr_accessor :project_path
+
+    # Used for :manual sometimes
+    attr_accessor :preferred_setup_method
+
+    # remember if there were multiple projects
+    # if so, we set it as part of the Pantfile
+    attr_accessor :had_multiple_projects_to_choose_from
+
+    # The current content of the generated Pantfile
+    attr_accessor :pantfile_content
+
+    # For iOS projects that's the Apple ID email
+    attr_accessor :user
+
+    # This is the lane that we tell the user to run to try the new pantograph setup
+    # This needs to be setup by each setup
+    attr_accessor :lane_to_mention
+
+    # Start the setup process
+    # rubocop:disable Metrics/BlockNesting
+    def self.start(user: nil)
+      if PantographCore::PantographFolder.setup? && !Helper.test?
+        require 'pantograph/lane_list'
+        Pantograph::LaneList.output(PantographCore::PantographFolder.pantfile_path)
+        UI.important("------------------")
+        UI.important("pantograph is already set up at path `#{PantographCore::PantographFolder.path}`, see the available lanes above")
+        UI.message("")
+
+        setup_ios = self.new
+        setup_ios.add_or_update_gemfile(update_gemfile_if_needed: false)
+        setup_ios.suggest_next_steps
+        return
+      end
+
+      # this is used by e.g. configuration.rb to not show warnings when running produce
+      ENV["PANTOGRAPH_ONBOARDING_IN_PROCESS"] = 1.to_s
+
+      spinner = TTY::Spinner.new("[:spinner] Looking for iOS and Android projects in current directory...", format: :dots)
+      spinner.auto_spin
+
+      maven_projects  = Dir["**/pom.xml"]
+      gradle_projects = Dir["**/*.gradle"] + Dir["**/*.gradle.kts"]
+
+      spinner.success
+
+      PantographCore::PantographFolder.create_folder!
+
+      # Currently we prefer iOS app projects, as the `init` process is
+      # more intelligent and does more things. The user can easily add
+      # the `:android` platform to the resulting Pantfile
+      if maven_projects.count > 0
+        current_directory = maven_projects.find_all do |current_project_path|
+          current_project_path.split(File::Separator).count == 1
+        end
+        chosen_project = nil
+        had_multiple_projects_to_choose_from = false
+
+        if current_directory.count == 1
+          chosen_project = current_directory.first
+        elsif current_directory.count > 1
+          if current_directory.count == 2
+            # This is a common case (e.g. with CocoaPods), where the project has an xcodeproj and an xcworkspace file
+            extensions = [File.extname(current_directory[0]), File.extname(current_directory[1])]
+            if extensions.sort == [".xcodeproj", ".xcworkspace"].sort
+              # Yep, that's this kind of setup
+              chosen_project = current_directory.find { |d| d.end_with?(".xcworkspace") }
+            end
+          end
+          chosen_project ||= UI.select("Multiple iOS projects found in current directory", current_directory)
+          had_multiple_projects_to_choose_from = true
+        else
+          UI.error("It looks like there is no iOS project in the current directory, though we did find one in a sub-directory")
+          UI.error("Please `cd` into the directory of the intended Xcode project you wish to use.")
+          UI.user_error!("Please `cd` into the directory of the intended Xcode project you wish to use and run `pantograph init` again")
+        end
+
+        UI.message("Detected an iOS/macOS project in the current directory: '#{chosen_project}'")
+
+        SetupIos.new(
+          user: user,
+          project_path: chosen_project,
+          had_multiple_projects_to_choose_from: had_multiple_projects_to_choose_from
+        ).setup_ios
+      elsif gradle_projects.count > 0
+        UI.message("Detected an Android project in the current directory...")
+        SetupAndroid.new.setup_android
+      else
+        UI.error("No iOS or Android projects were found in directory '#{Dir.pwd}'")
+        UI.error("Make sure to `cd` into the directory containing your iOS or Android app")
+        if UI.confirm("Alternatively, would you like to manually setup a pantograph config in the current directory instead?")
+          SetupIos.new(
+            user: user,
+            project_path: chosen_project,
+            had_multiple_projects_to_choose_from: had_multiple_projects_to_choose_from,
+            preferred_setup_method: :ios_manual
+          ).setup_ios
+        else
+          UI.user_error!("Make sure to `cd` into the directory containing your project and then use `pantograph init` again")
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockNesting
+
+    def initialize(user: nil, project_path: nil, had_multiple_projects_to_choose_from: nil, preferred_setup_method: nil)
+      self.user = user
+      self.project_path = project_path
+      self.had_multiple_projects_to_choose_from = had_multiple_projects_to_choose_from
+      self.preferred_setup_method = preferred_setup_method
+    end
+
+    # Helpers
+    def welcome_to_pantograph
+      UI.header("Welcome to pantograph 🚀")
+      UI.message("pantograph can help you with all kinds of automation")
+      UI.message("We recommend automating one task first, and then gradually automating more over time")
+    end
+
+    # Append a lane to the current Pantfile template we're generating
+    def append_lane(lane)
+      lane.compact! # remove nil values
+
+      new_lines = "\n\n"
+      new_lines = "" unless self.pantfile_content.include?("lane :") # the first lane we don't want new lines
+
+      self.pantfile_content.gsub!("[[LANES]]", "#{new_lines}  #{lane.join("\n  ")}[[LANES]]")
+    end
+
+    def write_pantfile!
+      # Write the Pantfile
+      pantfile_file_name = "Pantfile"
+
+      pantfile_path = File.join(PantographCore::PantographFolder.path, pantfile_file_name)
+      self.pantfile_content.gsub!("[[LANES]]", "") # since we always keep it until writing out
+      File.write(pantfile_path, self.pantfile_content) # remove trailing spaces before platform ends
+
+      add_or_update_gemfile(update_gemfile_if_needed: true)
+
+      UI.header("✅  Successfully generated pantograph configuration")
+      UI.message("Generated Pantfile at path `#{pantfile_path}`")
+      UI.message("Gemfile and Gemfile.lock at path `#{gemfile_path}`")
+
+      UI.message("Please check the newly generated configuration files into git along with your project")
+      UI.message("This way everyone in your team can benefit from your pantograph setup")
+      continue_with_enter
+    end
+
+    def gemfile_path
+      "Gemfile"
+    end
+
+    # Gemfile related code:
+    def gemfile_exists?
+      return File.exist?(gemfile_path)
+    end
+
+    def setup_gemfile!
+      # No Gemfile yet
+      gemfile_content = []
+      gemfile_content << "source \"https://rubygems.org\""
+      gemfile_content << ""
+      gemfile_content << 'gem "pantograph"'
+      gemfile_content << ""
+      File.write(gemfile_path, gemfile_content.join("\n"))
+
+      UI.message("Installing dependencies for you...")
+      PantographCore::CommandExecutor.execute(
+        command: "bundle update",
+        print_all: PantographCore::Globals.verbose?,
+        print_command: true,
+        error: proc do |error_output|
+          UI.error("Something went wrong when running `bundle update` for you")
+          UI.error("Please take a look at your Gemfile at path `#{gemfile_path}`")
+          UI.error("and make sure you can run `bundle update` on your machine.")
+        end
+      )
+    end
+
+    def ensure_gemfile_valid!(update_gemfile_if_needed: false)
+      gemfile_content = File.read(gemfile_path)
+      unless gemfile_content.include?("https://rubygems.org")
+        UI.error("You have a local Gemfile, but RubyGems isn't defined as source")
+        UI.error("Please update your Gemfile at path `#{gemfile_path}` to include")
+        UI.important("")
+        UI.important("source \"https://rubygems.org\"")
+        UI.important("")
+        UI.error("Update your Gemfile, and run `bundle update` afterwards")
+      end
+
+      unless gemfile_content.include?("pantograph")
+        if update_gemfile_if_needed
+          gemfile_content << "\n\ngem \"pantograph\""
+          UI.message("Adding `pantograph` to your existing Gemfile at path '#{gemfile_path}'")
+
+          File.write(gemfile_path, gemfile_content)
+        else
+          UI.error("You have a local Gemfile, but it doesn't include \"pantograph\" as a dependency")
+          UI.error("Please add `gem \"pantograph\"` to your Gemfile")
+        end
+      end
+    end
+
+    # This method is responsible for ensuring there is a working
+    # Gemfile, and that `pantograph` is defined as a dependency
+    # while also having `rubygems` as a gem source
+    def add_or_update_gemfile(update_gemfile_if_needed: false)
+      if gemfile_exists?
+        ensure_gemfile_valid!(update_gemfile_if_needed: update_gemfile_if_needed)
+      else
+        if update_gemfile_if_needed || UI.confirm("It is recommended to run pantograph with a Gemfile set up, do you want pantograph to create one for you?")
+          setup_gemfile!
+        end
+      end
+      return gemfile_path
+    end
+
+    def finish_up
+      write_pantfile!
+      show_analytics_note
+      explain_concepts
+      suggest_next_steps
+    end
+
+    def pantfile_template_content
+      path = "#{Pantograph::ROOT}/lib/assets/DefaultPantfileTemplate"
+      return File.read(path)
+    end
+
+    def explain_concepts
+      UI.header("pantograph lanes")
+      UI.message("pantograph uses a " + "`Pantfile`".yellow + " to store the automation configuration")
+      UI.message("Within that, you'll see different " + "lanes".yellow + ".")
+      UI.message("Each is there to automate a different task, like testing, building, or pushing new releases")
+      continue_with_enter
+
+      UI.header("How to customize your Pantfile")
+      UI.message("Use a text editor of your choice to open the newly created Pantfile and take a look")
+      UI.message("You can now edit the available lanes and actions to customize the setup to fit your needs")
+      UI.message("To get a list of all the available actions, open " + "https://johnknapprs.github.io/pantograph/".cyan)
+      continue_with_enter
+    end
+
+    def continue_with_enter
+      UI.input("Continue by pressing Enter ⏎")
+    end
+
+    def suggest_next_steps
+      UI.header("Where to go from here?")
+      if self.platform == :android
+        UI.message("📸  Learn more about how to automatically generate localized Google Play screenshots:")
+        UI.message("\t\thttps://docs.pantograph.tools/getting-started/android/screenshots/".cyan)
+        UI.message("👩‍✈️  Learn more about distribution to beta testing services:")
+        UI.message("\t\thttps://docs.pantograph.tools/getting-started/android/beta-deployment/".cyan)
+        UI.message("🚀  Learn more about how to automate the Google Play release process:")
+        UI.message("\t\thttps://docs.pantograph.tools/getting-started/android/release-deployment/".cyan)
+      else
+        UI.message("📸  Learn more about how to automatically generate localized App Store screenshots:")
+        UI.message("\t\thttps://docs.pantograph.tools/getting-started/ios/screenshots/".cyan)
+        UI.message("👩‍✈️  Learn more about distribution to beta testing services:")
+        UI.message("\t\thttps://docs.pantograph.tools/getting-started/ios/beta-deployment/".cyan)
+        UI.message("🚀  Learn more about how to automate the App Store release process:")
+        UI.message("\t\thttps://docs.pantograph.tools/getting-started/ios/appstore-deployment/".cyan)
+        UI.message("👩‍⚕️  Learn more about how to setup code signing with pantograph")
+        UI.message("\t\thttps://docs.pantograph.tools/codesigning/getting-started/".cyan)
+      end
+
+      # we crash here, so that this never happens when a new setup method is added
+      return if self.lane_to_mention.to_s.length == 0
+      UI.message("")
+      UI.message("To try your new pantograph setup, just enter and run")
+      UI.command("pantograph #{self.lane_to_mention}")
+    end
+
+    def show_analytics_note
+      UI.message("pantograph will collect the number of errors for each action to detect integration issues")
+      UI.message("No sensitive/private information will be uploaded, more information: " + "https://docs.pantograph.tools/#metrics".cyan)
+    end
+  end
+end
+
+require 'pantograph/setup/setup_ios'
+require 'pantograph/setup/setup_android'

data/pantograph/lib/pantograph/setup/setup_android.rb

@@ -0,0 +1,64 @@
+module Pantograph
+  class SetupAndroid < Setup
+    attr_accessor :json_key_file
+    attr_accessor :package_name
+
+    def setup_android
+      self.platform = :android
+
+      welcome_to_pantograph
+
+      self.pantfile_content = pantfile_template_content
+
+      fetch_information_for_appfile
+
+      PantographCore::PantographFolder.create_folder!
+
+      self.append_lane([
+                         "desc \"Runs all the tests\"",
+                         "lane :test do",
+                         "  gradle(task: \"test\")",
+                         "end"
+                       ])
+
+      self.append_lane([
+                         "desc \"Submit a new Beta Build to Crashlytics Beta\"",
+                         "lane :beta do",
+                         "  gradle(task: \"clean assembleRelease\")",
+                         "  crashlytics",
+                         "",
+                         "  # sh \"your_script.sh\"",
+                         "  # You can also use other beta testing services here",
+                         "end"
+                       ])
+
+      self.append_lane([
+                         "desc \"Deploy a new version to the Google Play\"",
+                         "lane :deploy do",
+                         "  gradle(task: \"clean assembleRelease\")",
+                         "  upload_to_play_store",
+                         "end"
+                       ])
+
+      self.lane_to_mention = "test"
+
+      finish_up
+    end
+
+    def fetch_information_for_appfile
+      UI.message('')
+      UI.message("To avoid re-entering your package name and issuer every time you run pantograph, we'll store those in a so-called Appfile.")
+
+      self.package_name = UI.input("Package Name (com.krausefx.app): ")
+      puts("")
+      puts("To automatically upload builds and metadata to Google Play, pantograph needs a service account json secret file".yellow)
+      puts("Feel free to press Enter at any time in order to skip providing pieces of information when asked")
+    end
+
+    def finish_up
+      self.pantfile_content.gsub!(":ios", ":android")
+
+      super
+    end
+  end
+end