capistrano_multiconfig_parallel 0.0.1

data/lib/capistrano_multiconfig_parallel/celluloid/state_machine.rb

@@ -0,0 +1,49 @@
+module CapistranoMulticonfigParallel
+  # class that handles the states of the celluloid worker executing the child process in a fork process
+  class StateMachine
+    include ComposableStateMachine::CallbackRunner
+    attr_accessor :state, :model, :machine, :job, :initial_state, :transitions, :output
+
+    def initialize(job, actor)
+      @job = job
+      @actor = actor
+      @initial_state = :unstarted
+      @model = generate_model
+      build_machine
+    end
+
+    def go_to_transition(action)
+      @machine.trigger(action.to_s)
+    end
+
+  private
+
+    def build_machine
+      @machine = ComposableStateMachine::MachineWithExternalState.new(
+        @model, method(:state), method(:state=), state: initial_state.to_s, callback_runner: self)
+    end
+
+    def generate_transitions
+      @transitions = ComposableStateMachine::Transitions.new
+      @transitions
+    end
+
+    def generate_model
+      ComposableStateMachine.model(
+        transitions: generate_transitions,
+        behaviors: {
+          enter: {
+            any: proc do |current_state, event, new_state|
+              actor_notify_state_change(current_state, event, new_state)
+            end
+          }
+        },
+        initial_state: @initial_state
+      )
+    end
+
+    def actor_notify_state_change(current_state, event, new_state)
+      @actor.send_msg(CapistranoMulticonfigParallel::TerminalTable::TOPIC, type: 'event', message: "Going from #{current_state} to #{new_state}  due to a #{event} event")
+    end
+  end
+end

data/lib/capistrano_multiconfig_parallel/celluloid/terminal_table.rb

@@ -0,0 +1,122 @@
+
+module CapistranoMulticonfigParallel
+  # class used to display the progress of each worker on terminal screen using a table
+  # rubocop:disable ClassLength
+  class TerminalTable
+    include Celluloid
+    include Celluloid::Notifications
+    include Celluloid::Logger
+    TOPIC = 'sshkit_terminal'
+
+    def initialize(manager)
+      @manager = manager
+      async.run
+    end
+
+    def run
+      subscribe(CapistranoMulticonfigParallel::TerminalTable::TOPIC, :notify_time_change)
+    end
+
+    def notify_time_change(topic, message)
+      return unless topic == CapistranoMulticonfigParallel::TerminalTable::TOPIC
+      default_headings = ['Job ID', 'App/Stage', 'Action', 'ENV Variables', 'Current Task']
+      if CapistranoMulticonfigParallel.show_task_progress
+        default_headings << 'Total'
+        default_headings << 'Progress'
+      end
+      table = Terminal::Table.new(title: 'Deployment Status Table', headings: default_headings)
+      if @manager.jobs.present? && message_valid?(message)
+        @manager.jobs.each do |job_id, _job|
+          add_job_to_table(table, job_id)
+        end
+      end
+      show_terminal_screen(table)
+    rescue => ex
+      info "Terminal Table  client disconnected due to error #{ex.inspect}"
+      info ex.backtrace
+      terminate
+    end
+
+    def message_valid?(message)
+      message[:type].present? && message[:type] == 'output' || message[:type] == 'event'
+    end
+
+    def show_terminal_screen(table)
+      return unless table.rows.present?
+      terminal_clear
+      puts "\n"
+      #  table.style = { width: 20 }
+      puts table
+      puts "\n"
+      sleep(1)
+    end
+
+    def add_job_to_table(table, job_id)
+      worker = @manager.get_worker_for_job(job_id)
+      return unless worker.present?
+      worker_optons = ''
+      worker.env_options.each do |key, value|
+        worker_optons << "#{key}=#{value}\n"
+      end
+      state = worker.machine.state.to_s
+      state = worker_crashed?(worker) ? state.red : state.green
+      row = [{ value: worker.job_id.to_s },
+             { value: "#{worker.app_name}\n#{worker.env_name}" },
+             { value: worker.action_name },
+             { value: worker_optons },
+             { value: state }
+            ]
+      if CapistranoMulticonfigParallel.show_task_progress
+        row << { value: worker.rake_tasks.size }
+        row << { value: worker_progress(worker) }
+      end
+      table.add_row(row)
+      table.add_separator if @manager.jobs.keys.last.to_i != job_id.to_i
+    end
+
+    def terminal_clear
+      system('cls') || system('clear') || puts("\e[H\e[2J")
+    end
+
+    def worker_crashed?(worker)
+      worker.crashed?
+    end
+    # rubocop:disable Lint/Eval
+    def capture(stream)
+      stream = stream.to_s
+      captured_stream = Tempfile.new(stream)
+      stream_io = eval("$#{stream}")
+      origin_stream = stream_io.dup
+      stream_io.reopen(captured_stream)
+
+      yield
+
+      stream_io.rewind
+      return captured_stream.read
+    ensure
+      captured_stream.close
+      captured_stream.unlink
+      stream_io.reopen(origin_stream)
+    end
+
+    def worker_progress(worker)
+      tasks = worker.rake_tasks
+      current_task = worker.machine.state
+      total_tasks = tasks.size
+      task_index = tasks.index(current_task)
+      progress = Formatador::ProgressBar.new(total_tasks, color: 'green', start: task_index.to_i)
+      result = capture(:stdout) do
+        progress.increment
+      end
+      result = result.gsub("\r\n", '')
+      result = result.gsub("\n", '')
+      result = result.gsub('|', '#')
+      result = result.gsub(/\s+/, ' ')
+      if worker_crashed?(worker)
+        return result.red
+      else
+        return result.green
+      end
+    end
+  end
+end

data/lib/capistrano_multiconfig_parallel/cli.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'bundler'
+require 'bundler/setup'
+require 'rake'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/concern'
+require 'celluloid/autostart'
+require 'celluloid/pmap'
+require 'composable_state_machine'
+require 'formatador'
+require 'eventmachine'
+require 'right_popen'
+require 'colorize'
+require 'logger'
+require 'terminal-table'
+require 'colorize'
+require 'celluloid_pubsub'
+require 'capistrano/all'
+require 'fileutils'
+require 'logger'
+require 'pp'
+require 'configurations'
+# fix error with not files that can not be found
+Gem.find_files('composable_state_machine/**/*.rb').each { |path| require path }
+
+Gem.find_files('capistrano_multiconfig_parallel/initializers/**/*.rb').each { |path| require path }
+Gem.find_files('capistrano_multiconfig_parallel/helpers/**/*.rb').each { |path| require path }
+Gem.find_files('capistrano_multiconfig_parallel/celluloid/**/*.rb').each { |path| require path }
+
+require_relative './base'
+require_relative 'application'
+
+module CapistranoMulticonfigParallel
+  # this is the class that will be invoked from terminal , and willl use the invoke task as the primary function.
+  class CLI
+    def self.start
+      if $stdin.isatty
+        $stdin.sync = true
+      end
+      if $stdout.isatty
+        $stdout.sync = true
+      end
+      CapistranoMulticonfigParallel.configuration_valid?
+      CapistranoMulticonfigParallel.verify_app_dependencies(stages) if CapistranoMulticonfigParallel.configuration.track_dependencies
+      CapistranoMulticonfigParallel::Application.new.run
+    rescue Interrupt
+      `stty icanon echo`
+      $stderr.puts 'Command cancelled.'
+    rescue => error
+      $stderr.puts error
+      exit(1)
+    end
+  end
+end

data/lib/capistrano_multiconfig_parallel/configuration.rb

@@ -0,0 +1,70 @@
+require_relative './initializers/conf'
+module CapistranoMulticonfigParallel
+  # class that holds the options that are configurable for this gem
+  module Configuration
+    extend ActiveSupport::Concern
+
+    included do
+      include Configurations
+
+      configurable Hash, :websocket_server
+      configurable Array, :development_stages
+
+      configurable :track_dependencies do |value|
+        check_boolean(:track_dependencies, value)
+      end
+
+      configurable Array, :application_dependencies do |value|
+        value.reject { |val| val.blank? || !val.is_a?(Hash) }
+        wrong = value.find do|hash|
+          !Set[:app, :priority, :dependencies].subset?(hash.keys.to_set) ||
+          hash[:app].blank? ||
+          hash[:priority].blank?
+          !hash[:priority].is_a?(Numeric) ||
+          !hash[:dependencies].is_a?(Array)
+        end
+        raise ArgumentError, "invalid configuration for #{wrong.inspect}" if wrong.present?
+      end
+
+      configurable :task_confirmation_active do |value|
+        check_boolean(:task_confirmation_active, value)
+      end
+
+      configurable Array, :task_confirmations do |value|
+        value.reject(&:blank?)
+        if value.find { |row| !row.is_a?(String) }
+          raise ArgumentError, 'the array must contain only task names'
+        end
+      end
+
+      configuration_defaults do |c|
+        c.task_confirmations = ['deploy:symlink:release']
+        c.task_confirmation_active = false
+        c.track_dependencies = false
+        c.websocket_server = { enable_debug: false }
+        c.development_stages = ['development', 'webdev']
+      end
+
+      not_configured do |prop| # omit the arguments to get a catch-all not_configured
+        raise NoMethodError, "Please configure the property `#{prop}` by assigning a value of type #{configuration.property_type(prop)}"
+      end
+
+      def self.value_is_boolean?(value)
+        [true, false, 'true', 'false'].include?(value)
+      end
+
+      def self.check_boolean(prop, value)
+        unless value_is_boolean?(value)
+          raise ArgumentError, "the property `#{prop}` must be boolean"
+        end
+      end
+
+      def self.configuration_valid?
+        configuration.nil? &&
+          configuration.task_confirmations &&
+          ((configuration.track_dependencies && configuration.application_dependencies) ||
+            configuration.track_dependencies == false)
+      end
+    end
+  end
+end

data/lib/capistrano_multiconfig_parallel/helpers/base_manager.rb

@@ -0,0 +1,217 @@
+require_relative './standard_deploy'
+module CapistranoMulticonfigParallel
+  # finds app dependencies, shows menu and delegates jobs to celluloid manager
+  # rubocop:disable ClassLength
+  class BaseManager
+    include Celluloid
+    include Celluloid::Logger
+
+    attr_accessor :condition, :manager, :deps, :application, :stage, :name, :args, :argv, :jobs, :job_registered_condition, :default_stage
+
+    def initialize(cap_app, top_level_tasks, stages)
+      @cap_app = cap_app
+      @top_level_tasks = top_level_tasks
+      @stages = stages
+      @jobs = []
+    end
+
+    def can_start?
+      @top_level_tasks.size > 1 && (stages.include?(@top_level_tasks.first) || custom_command?) && ENV[CapistranoMulticonfigParallel::ENV_KEY_JOB_ID].blank?
+    end
+
+    def custom_command?
+      @top_level_tasks.first == 'ensure_stage' && !stages.include?(@top_level_tasks.second) && !stages.include?(@top_level_tasks.first) && custom_commands.values.include?(@top_level_tasks.second)
+    end
+
+    def custom_commands
+      key = multi_apps? ? CapistranoMulticonfigParallel::MULTI_KEY : CapistranoMulticonfigParallel::SINGLE_KEY
+      CapistranoMulticonfigParallel::CUSTOM_COMMANDS[key]
+    end
+
+    def multi_apps?
+      @cap_app.multi_apps?
+    end
+
+    def start(&block)
+      @application = custom_command? ? nil : @top_level_tasks.first.split(':').reverse[1]
+      @stage = custom_command? ? nil : @top_level_tasks.first.split(':').reverse[0]
+      @name, @args = @cap_app.parse_task_string(@top_level_tasks.second)
+      @argv = @cap_app.handle_options.delete_if { |arg| arg == @stage || arg == @name || arg == @top_level_tasks.first }
+      @argv = multi_fetch_argv(@argv)
+      CapistranoMulticonfigParallel.enable_logging
+      block.call if block_given?
+      run
+    end
+
+    def collect_jobs(options = {}, &block)
+      options = prepare_options(options)
+      block.call(options) if block_given?
+    rescue => e
+      raise [e, e.backtrace].inspect
+    end
+
+    def process_jobs(&block)
+      return unless @jobs.present?
+      if CapistranoMulticonfigParallel.execute_in_sequence
+        @jobs.each { |job| CapistranoMulticonfigParallel::StandardDeploy.execute_standard_deploy(job) }
+      else
+        run_async_jobs(&block)
+      end
+    end
+    
+    def fetch_multi_stages
+      stages = @argv['STAGES'].blank? ? '' : @argv['STAGES']
+      stages = parse_inputted_value(value: stages).split(',').compact if stages.present?
+      stages
+    end
+  
+    
+    def deploy_app(options = {})
+      options = options.stringify_keys
+      app = options['app'].is_a?(Hash) ?  options['app'] : {'app' =>  options['app'] }
+      branch = @branch_backup.present? ? @branch_backup : @argv['BRANCH'].to_s
+      call_task_deploy_app({
+          branch: branch,
+          app: app ,
+          action: options['action']
+        }.reverse_merge(options))
+    end
+
+    private
+  
+    def call_task_deploy_app(options = {})
+      options = options.stringify_keys
+      main_box_name = @argv['BOX'].blank? ? '' : @argv['BOX']
+      stage = options.fetch('stage', @default_stage )
+      if CapistranoMulticonfigParallel.configuration.development_stages.include?(stage) && main_box_name.present? && /^[a-z0-9,]+/.match(main_box_name)
+        execute_on_multiple_boxes(main_box_name, options)
+      else
+        prepare_job(options)
+      end
+    end
+
+    def run_async_jobs(&block)
+      return unless @jobs.present?
+      @condition = Celluloid::Condition.new
+      @manager = CapistranoMulticonfigParallel::CelluloidManager.new(Actor.current)
+      @jobs.pmap do |job|
+        @manager.async.delegate(job)
+      end
+      until @manager.registration_complete
+        sleep(0.1) # keep current thread alive
+      end
+      return unless @manager.registration_complete
+      @manager.process_jobs(&block)
+      wait_jobs_termination
+    end
+
+    def wait_jobs_termination
+      return if @jobs.blank? || CapistranoMulticonfigParallel.execute_in_sequence
+      result = @condition.wait
+      return unless result.present?
+      @manager.terminate
+      terminate
+    end
+
+    def prepare_job(options)
+      options = options.stringify_keys
+      branch_name = options.fetch('branch', {})
+      app = options.fetch('app', {})
+      app = app.fetch('app', '')
+      box = options['env_options']['BOX']
+      message = box.present? ? "BOX #{box}:" : "stage #{options['stage']}:"
+      branch_name = get_applications_branch_from_stdin(app, message) if branch_name.blank?
+      env_opts = get_app_additional_env_options(app, message)
+
+      options['env_options'] = options['env_options'].reverse_merge(env_opts)
+      env_options = {
+        'BRANCH' => branch_name
+      }.merge(options['env_options'])
+
+      job = {
+        app: app,
+        env: options['stage'],
+        action: options['action'],
+        task_arguments: options['task_arguments'],
+        env_options: env_options
+      }
+
+      @jobs << job
+    end
+
+    def prepare_options(options)
+      @default_stage = CapistranoMulticonfigParallel.configuration.development_stages.present? ? CapistranoMulticonfigParallel.configuration.development_stages.first : 'development'
+      @stage = @stage.present? ? @stage : @default_stage
+      options = options.stringify_keys
+      options['app'] = options.fetch('app', @application.to_s.clone)
+      options['action'] = options.fetch('action', @name.to_s.clone)
+      options['stage'] = options.fetch('stage', @stage.to_s.clone)
+      options['env_options'] = options.fetch('env_options', @argv.clone)
+      options['task_arguments'] = options.fetch('task_arguments', @args.clone)
+      options
+    end
+
+    def parse_inputted_value(options = {})
+      options = options.stringify_keys
+      value = options['value'].present? ? options['value'] : fetch(options.fetch('key', :app_branch_name))
+      if value.present?
+        branch = value.gsub("\r\n", '')
+        branch = branch.gsub("\n", '') if branch.present?
+        branch = branch.gsub(/\s+/, ' ') if branch.present?
+        branch = branch.strip if branch.present?
+        return branch
+      else
+        return ''
+      end
+    end
+
+    def get_applications_branch_from_stdin(app, app_message)
+      app_name = (app.is_a?(Hash) && app[:app].present?) ? app[:app].camelcase : app
+      app_name = app_name.present? ? app_name :  "current application"
+      message = "Branch name for  #{app_name} for #{app_message} :"
+      branch = ''
+      if @argv['BRANCH'].blank? || (@argv['BRANCH'].present? && !custom_command?)
+        set :app_branch_name, ask(message, nil)
+        branch = parse_inputted_value
+      else
+        branch = @argv['BRANCH']
+      end
+      branch
+    end
+    
+    def get_app_additional_env_options(app, app_message)
+      app_name = (app.is_a?(Hash) && app[:app].present?) ? app[:app].camelcase : app
+      app_name = app_name.present? ? app_name :  "current application"
+      message = "Please write additional ENV options for #{app_name} for #{app_message} :"
+      set :app_additional_env_options, ask_confirm(message, nil)
+      fetch_app_additional_env_options
+    end
+
+    def fetch_app_additional_env_options
+      options = {}
+      return options if fetch(:app_additional_env_options).blank?
+      env_options = parse_inputted_value(key: :app_additional_env_options)
+      env_options = env_options.split(' ')
+      options = multi_fetch_argv(env_options)
+      options
+    end
+
+    def multi_fetch_argv(args)
+      options = {}
+      args.each do |arg|
+        if arg =~ /^(\w+)=(.*)$/m
+          options[Regexp.last_match(1)] = Regexp.last_match(2)
+        end
+      end
+      options
+    end
+
+    def execute_on_multiple_boxes(main_box_name, options)
+      boxes = parse_inputted_value(value: main_box_name).split(',').compact
+      boxes.each do |box_name|
+        options['env_options']['BOX'] = box_name
+        prepare_job(options)
+      end
+    end
+  end
+end

data/lib/capistrano_multiconfig_parallel/helpers/multi_app_manager.rb

@@ -0,0 +1,84 @@
+require_relative './base_manager'
+require_relative '../multi_app_helpers/dependency_tracker'
+module CapistranoMulticonfigParallel
+  # class used to find application dependencies
+  class MultiAppManager < CapistranoMulticonfigParallel::BaseManager
+    include Celluloid
+    include Celluloid::Logger
+
+    def initialize(cap_app, top_level_tasks, stages)
+      super(cap_app, top_level_tasks, stages)
+      @dependency_tracker = CapistranoMulticonfigParallel::DependencyTracker.new(Actor.current)
+    end
+
+    def run
+      options = {}
+      if custom_command?
+        run_custom_command(options)
+      else
+        menu_deploy_interactive(options)
+      end
+      process_jobs
+    end
+
+    def run_custom_command(options)
+      return unless custom_command?
+      CapistranoMulticonfigParallel.interactive_menu = true
+      options[:action] = @argv['ACTION'].present? ? @argv['ACTION'].present? : 'deploy'
+      action_name = @name
+      if action_name == custom_commands[:menu]
+        menu_deploy_interactive(options)
+      elsif action_name == custom_commands[:stages]
+        multi_stage_deploy(options)
+      else
+        raise "Custom command #{@name} not available for multi apps"
+      end
+    end
+
+    def multi_stage_deploy(options)
+      stages = fetch_multi_stages
+      return if  stages.blank?
+      multi_collect_and_run_jobs(options) do |apps, new_options|
+        apps.each do |app|
+          stages.each do |stage|
+            deploy_app(new_options.merge('app' => app, 'stage' => stage))
+          end
+        end if apps.present?
+      end
+    end
+        
+    def menu_deploy_interactive(options)
+      multi_collect_and_run_jobs(options) do |apps, new_options|
+        deploy_multiple_apps(apps, new_options)
+        deploy_app(new_options) if !custom_command? && new_options['app'].present?
+      end
+    end
+    
+    private
+    
+     
+    def multi_collect_and_run_jobs(options = {}, &block)
+      collect_jobs(options) do |new_options|
+        applications = @dependency_tracker.fetch_apps_needed_for_deployment(new_options['app'], new_options['action'])
+        backup_the_branch
+        block.call(applications, new_options) if block_given?
+      end
+    end
+
+    def backup_the_branch
+      return if  custom_command? ||  @argv['BRANCH'].blank?
+      @branch_backup = @argv['BRANCH'].to_s
+      @argv['BRANCH'] = nil
+    end
+    
+    def deploy_multiple_apps(applications,  options)
+      options = options.stringify_keys
+      return unless applications.present?
+      applications.each do |app|
+        deploy_app(options.merge('app' => app))
+      end
+    end
+
+    
+  end
+end

data/lib/capistrano_multiconfig_parallel/helpers/single_app_manager.rb

@@ -0,0 +1,48 @@
+require_relative './base_manager'
+module CapistranoMulticonfigParallel
+  # class used to find application dependencies
+  class SingleAppManager < CapistranoMulticonfigParallel::BaseManager
+    include Celluloid
+    include Celluloid::Logger
+
+    def run
+      options = {}
+      if custom_command?
+        run_custom_command(options)
+      else
+        deploy_single_app(options)
+      end
+      process_jobs
+    end
+
+    def run_custom_command(options)
+      return unless custom_command?
+      action_name = @name
+      if action_name == custom_commands[:stages]
+        stage_deploy(options)
+      else
+        raise "Custom command #{@name} not available for single apps"
+      end
+    end
+
+    def stage_deploy(options)
+       return unless custom_command?
+      stages = fetch_multi_stages
+      return if  stages.blank?
+      collect_jobs(options) do |new_options|
+        stages.each do |stage|
+          deploy_app(new_options.merge('stage' => stage, 'action' => 'deploy'))
+        end
+      end
+    end
+    
+    
+    def deploy_single_app(options)
+      return if custom_command?
+      collect_jobs(options) do |new_options|
+        deploy_app(new_options) 
+      end
+    end
+    
+  end
+end

data/lib/capistrano_multiconfig_parallel/helpers/standard_deploy.rb

@@ -0,0 +1,40 @@
+require 'fileutils'
+module CapistranoMulticonfigParallel
+  # class used to find application dependencies
+  class StandardDeploy
+    extend FileUtils
+
+    def self.setup_command_line_standard(options)
+      opts = ''
+      options.each do |key, value|
+        opts << "#{key}=#{value}" if value.present?
+      end
+      opts
+    end
+
+    def self.execute_standard_deploy(options)
+      app = options.fetch(:app, '')
+      stage = options.fetch(:env, 'development')
+      action_name = options.fetch(:action, 'deploy')
+      action = "#{action_name}[#{options.fetch(:task_arguments, []).join(',')}]"
+      arguments = setup_command_line_standard(options.fetch(:env_options, {}))
+
+      command = "bundle exec cap #{app}:#{stage} #{action}  #{arguments}"
+      puts("\n\n\n Executing '#{command}' \n\n\n .")
+      sh("#{command}")
+    rescue => ex
+      CapistranoMulticonfigParallel.log_message(ex)
+      if @name == 'deploy'
+        begin
+          action = "deploy:rollback[#{options.fetch(:task_arguments, []).join(',')}]"
+          command = "bundle exec cap #{app}:#{stage} #{action} #{arguments}"
+          puts("\n\n\n Executing #{command} \n\n\n .")
+          sh("#{command}")
+        rescue => exception
+          CapistranoMulticonfigParallel.log_message(exception)
+          # nothing to do if rollback fails
+        end
+      end
+    end
+  end
+end

data/lib/capistrano_multiconfig_parallel/initializers/conf.rb

@@ -0,0 +1,6 @@
+Configurations::StrictConfiguration.class_eval do
+  def property_type(property)
+    return unless __configurable?(property)
+    @__configurable__[property][:type]
+  end
+end