capistrano_multiconfig_parallel 0.15.6 → 0.16.0

data/lib/capistrano_multiconfig_parallel/application.rb

@@ -1,20 +1,349 @@
 module CapistranoMulticonfigParallel
-  # class used as a wrapper around capistrano
-  class Application < Capistrano::Application
-    def name
-      'multi_cap'
+  # finds app dependencies, shows menu and delegates jobs to celluloid manager
+  # rubocop:disable ClassLength
+  class Application
+    include Celluloid
+    include Celluloid::Logger
+
+    attr_accessor :stages,:stage_apps, :top_level_tasks, :jobs, :branch_backup, :condition, :manager, :dependency_tracker, :application, :stage, :name, :args, :argv, :default_stage
+
+    def initialize
+      @stages = fetch_stages
+      @stage_apps =  multi_apps? ? @stages.map { |stage| stage.split(':').reverse[1] }.uniq : []
+      collect_command_line_tasks(CapistranoMulticonfigParallel.original_args)
+      @jobs = []
+      CapistranoMulticonfigParallel.configuration_valid?(@stages)
+    end
+
+
+    def start
+      verify_app_dependencies(@stages) if multi_apps? && configuration.application_dependencies.present?
+      check_before_starting
+      initialize_data
+      run
+    end
+
+    def verify_app_dependencies(stages)
+      wrong = configuration.application_dependencies.find do |hash|
+        !@stage_apps.include?(hash[:app]) || (hash[:dependencies].present? && hash[:dependencies].find { |val| !@stage_apps.include?(val) })
+      end
+      raise ArgumentError,"Invalid configuration for #{wrong.inspect}".red if wrong.present?
+    end
+
+
+    def fetch_stages
+      fetch_stages_paths do |paths|
+        paths.reject! { |path| check_stage_path(paths, path) }
+        paths.sort if paths.present?
+      end
+    end
+
+    def check_stage_path(paths, path)
+      paths.any? { |another| another != path && another.start_with?(path + ':') }
+    end
+
+    def stages_paths
+      stages_root = 'config/deploy'
+      Dir["#{stages_root}/**/*.rb"].map do |file|
+        file.slice(stages_root.size + 1..-4).tr('/', ':')
+      end
+    end
+
+    def fetch_stages_paths
+      stages_paths.tap { |paths| yield paths if block_given? }
+    end
+
+
+
+    def run_custom_command(options)
+      custom_stages = fetch_multi_stages
+      return if custom_stages.blank?
+      custom_stages = check_multi_stages(custom_stages)
+      custom_stages.each do |stage|
+        collect_jobs(options.merge('stage' => stage))
+      end
+    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
+
+    def backup_the_branch
+      return if custom_command? || @argv['BRANCH'].blank?
+      @branch_backup = @argv['BRANCH'].to_s
+      @argv['BRANCH'] = nil
+    end
+
+    def can_start?
+      @top_level_tasks.size >= 1 && (@stages.include?(@top_level_tasks.first) || custom_command?) && @argv[CapistranoMulticonfigParallel::ENV_KEY_JOB_ID].blank?
+    end
+
+    def custom_command?
+      if multi_apps?
+        !@stages.include?(@top_level_tasks.first) && custom_commands.values.include?(@top_level_tasks.first)
+      else
+        !@stages.include?(@top_level_tasks.second) && @stages.include?(@top_level_tasks.first) && custom_commands.values.include?(@top_level_tasks.second)
+      end
+    end
+
+    def custom_commands
+      key = multi_apps? ? CapistranoMulticonfigParallel::MULTI_KEY : CapistranoMulticonfigParallel::SINGLE_KEY
+      CapistranoMulticonfigParallel::CUSTOM_COMMANDS[key]
+    end
+
+    def multi_apps?
+      @stages.find { |stage| stage.include?(':') }.present?
+    end
+
+    def configuration
+      CapistranoMulticonfigParallel.configuration
+    end
+
+
+    def initialize_data
+      @application = custom_command? ? nil : @top_level_tasks.first.split(':').reverse[1]
+      @stage = custom_command? ? nil : @top_level_tasks.first.split(':').reverse[0]
+      @stage = @stage.present? ? @stage : @default_stage
+      @name, @args = parse_task_string(@top_level_tasks.second)
+    end
+
+    def collect_command_line_tasks(args) # :nodoc:
+      @argv = {}
+      @top_level_tasks = []
+      args.each do |arg|
+        if arg =~ /^(\w+)=(.*)$/m
+          @argv[Regexp.last_match(1)] = Regexp.last_match(2)
+        else
+          @top_level_tasks << arg unless arg =~ /^-/
+        end
+      end
+      @top_level_tasks.push(Rake.application.default_task_name) if @top_level_tasks.blank?
+    end
+
+    def parse_task_string(string) # :nodoc:
+      /^([^\[]+)(?:\[(.*)\])$/ =~ string.to_s
+
+      name           = Regexp.last_match(1)
+      remaining_args = Regexp.last_match(2)
+
+      return string, [] unless name
+      return name,   [] if     remaining_args.empty?
+
+      args = []
+
+      loop do
+        /((?:[^\\,]|\\.)*?)\s*(?:,\s*(.*))?$/ =~ remaining_args
+
+        remaining_args = Regexp.last_match(2)
+        args << Regexp.last_match(1).gsub(/\\(.)/, '\1')
+        break if   remaining_args.blank?
+      end
+
+      [name, args]
+    end
+
+    def verify_options_custom_command(options)
+      options[:action] = @argv['ACTION'].present? ? @argv['ACTION'] : 'deploy'
+      options
+    end
+
+    def check_before_starting
+      CapistranoMulticonfigParallel.enable_logging
+      @dependency_tracker = CapistranoMulticonfigParallel::DependencyTracker.new(Actor.current)
+      @default_stage = CapistranoMulticonfigParallel.configuration.development_stages.present? ? CapistranoMulticonfigParallel.configuration.development_stages.first : 'development'
+      @condition = Celluloid::Condition.new
+      @manager = CapistranoMulticonfigParallel::CelluloidManager.new(Actor.current)
+    end
+
+    def collect_jobs(options = {}, &_block)
+      options = prepare_options(options)
+      options = options.stringify_keys
+      apps = @dependency_tracker.fetch_apps_needed_for_deployment(options['app'], options['action'])
+      backup_the_branch if multi_apps?
+      deploy_multiple_apps(apps, options)
+      deploy_app(options) if !custom_command? || !multi_apps?
+    rescue => e
+      CapistranoMulticonfigParallel.log_message(e)
+    end
+
+    def process_jobs
+      return unless @jobs.present?
+      FileUtils.rm Dir["#{CapistranoMulticonfigParallel.log_directory}/worker_*.log"]
+      if configuration.multi_secvential.to_s.downcase == 'true'
+        @jobs.each { |job| CapistranoMulticonfigParallel::StandardDeploy.new(job) }
+      else
+        run_async_jobs
+      end
+    end
+
+    def tag_staging_exists? # check exists task from capistrano-gitflow
+      CapistranoMulticonfigParallel.find_loaded_gem('capistrano-gitflow').present?
+    end
+
+
+    def fetch_multi_stages
+      custom_stages = @argv['STAGES'].blank? ? '' : @argv['STAGES']
+      custom_stages = parse_inputted_value('value' => custom_stages).split(',').compact if custom_stages.present?
+      custom_stages = custom_stages.present? ? custom_stages : [@default_stage]
+      custom_stages
+    end
+
+    def wants_deploy_production?
+      (!custom_command? && @stage == 'production') || (custom_command? && fetch_multi_stages.include?('production'))
+    end
+
+    def can_tag_staging?
+      wants_deploy_production? && tag_staging_exists? && fetch_multi_stages.include?('staging')
+    end
+
+    def check_multi_stages(custom_stages)
+      can_tag_staging? ? custom_stages.reject { |u| u == 'production' } : custom_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
 
-    def sort_options(options)
-      super.concat(CapistranoMulticonfigParallel.capistrano_options)
+    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}"
+      app_additional_env_options = CapistranoMulticonfigParallel.ask_confirm(message, nil)
+      fetch_app_additional_env_options(app_additional_env_options)
     end
 
-    def top_level
-      job_manager = CapistranoMulticonfigParallel::BaseManager.new
-      if job_manager.can_start? && !options.show_prereqs && !options.show_tasks
-        job_manager.start
+    def worker_environments
+      @jobs.map { |job| job['env'] }
+    end
+
+    def run
+      options = {}
+      if custom_command?
+        options = verify_options_custom_command(options)
+        run_custom_command(options)
       else
-        super
+        collect_jobs(options)
+      end
+      process_jobs
+    end
+
+    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
+      return unless @jobs.present?
+      @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.async.process_jobs
+      wait_jobs_termination
+    end
+
+    def wait_jobs_termination
+      return if configuration.multi_secvential.to_s.downcase == 'true'
+      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']}:"
+      env_opts = get_app_additional_env_options(app, message)
+
+      options['env_options'] = options['env_options'].reverse_merge(env_opts)
+
+      env_options = branch_name.present? ? { 'BRANCH' => branch_name }.merge(options['env_options']) : options['env_options']
+      job_env_options = custom_command? && env_options['ACTION'].present? ? env_options.except('ACTION') : env_options
+
+      job = {
+        id: SecureRandom.random_number(500),
+        app: app,
+        env: options['stage'],
+        action: custom_command? && env_options['ACTION'].present? ? env_options['ACTION'] : options['action'],
+        task_arguments: options['task_arguments'],
+        env_options: job_env_options
+      }
+      @jobs << job.stringify_keys
+    end
+
+    def prepare_options(options)
+      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'] : nil
+      if value.present?
+        branch = value.gsub("\r\n", '')
+        branch = branch.delete("\n") if branch.present?
+        branch = branch.gsub(/\s+/, ' ') if branch.present?
+        branch = branch.strip if branch.present?
+        return branch
+      else
+        return ''
+      end
+    end
+
+    def fetch_app_additional_env_options(variable)
+      options = {}
+      return options if variable.blank?
+      env_options = parse_inputted_value('value' => variable)
+      env_options = env_options.split(' ')
+      options = multi_fetch_argv(env_options)
+      options.stringify_keys!
+      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

data/lib/capistrano_multiconfig_parallel/base.rb

@@ -1,6 +1,7 @@
 # base module that has the statis methods that this gem is using
 module CapistranoMulticonfigParallel
   include CapistranoMulticonfigParallel::Configuration
+  include Helper
 
   ENV_KEY_JOB_ID = 'multi_cap_job_id'
   MULTI_KEY = 'multi'
@@ -57,10 +58,8 @@ module CapistranoMulticonfigParallel
       FileUtils.mkdir_p(log_directory) unless File.directory?(log_directory)
       if CapistranoMulticonfigParallel::CelluloidManager.debug_enabled.to_s.downcase == 'true'
         FileUtils.touch(main_log_file) unless File.file?(main_log_file)
-        if ENV[CapistranoMulticonfigParallel::ENV_KEY_JOB_ID].blank?
-          log_file = File.open(main_log_file, 'w')
-          log_file.sync = true
-        end
+        log_file = File.open(main_log_file, 'w')
+        log_file.sync = true
         self.logger = ::Logger.new(main_log_file)
       else
         self.logger = ::Logger.new(DevNull.new)
@@ -75,15 +74,16 @@ module CapistranoMulticonfigParallel
       err_backtrace = message.respond_to?(:backtrace) ? message.backtrace.join("\n\n") : ''
       if err_backtrace.present?
         logger.debug(
-          class_name: message.class,
-          message: error_message,
-          backtrace: err_backtrace
+        class_name: message.class,
+        message: error_message,
+        backtrace: err_backtrace
         )
       else
         logger.debug(message)
       end
     end
 
+
     def detect_root
       if ENV['MULTI_CAP_ROOT']
         Pathname.new(ENV['MULTI_CAP_ROOT'])
@@ -98,7 +98,7 @@ module CapistranoMulticonfigParallel
       root = Pathname.new(FileUtils.pwd)
       root = root.parent unless root.directory?
       root = root.parent until root.children.find { |f| f.file? && f.basename.to_s.downcase == 'capfile' }.present? || root.root?
-      raise "Can't detect Capfile in the  application root" if root.root?
+      raise "Can't detect Capfile in the  application root".red if root.root?
       root
     end
   end

data/lib/capistrano_multiconfig_parallel/celluloid/celluloid_manager.rb

@@ -54,10 +54,7 @@ module CapistranoMulticonfigParallel
     end
 
     def generate_job_id(job)
-      primary_key = SecureRandom.random_number(500)
-      job['id'] = primary_key
-      @jobs[primary_key] = job
-      @jobs[primary_key]
+      @jobs[job['id']] = job
       job['id']
     end
 
@@ -181,8 +178,8 @@ module CapistranoMulticonfigParallel
       message = "Do you want  to continue the deployment and execute #{task.upcase}"
       message += " for JOB #{worker.job_id}" if worker.present?
       message += '?'
-      set :apps_symlink_confirmation, Celluloid::Actor[:terminal_server].show_confirmation(message, 'Y/N')
-      until fetch(:apps_symlink_confirmation).present?
+      apps_symlink_confirmation = Celluloid::Actor[:terminal_server].show_confirmation(message, 'Y/N')
+      until apps_symlink_confirmation.present?
         sleep(0.1) # keep current thread alive
       end
     end

data/lib/capistrano_multiconfig_parallel/celluloid/celluloid_worker.rb

@@ -83,6 +83,12 @@ module CapistranoMulticonfigParallel
       "cd #{CapistranoMulticonfigParallel.detect_root}"
     end
 
+    # def generate_command_new
+    #   <<-CMD
+    #     bundle exec ruby -e "require 'bundler' ;   Bundler.with_clean_env { %x[cd #{cd_working_directory} && bundle install && RAILS_ENV=#{@env_name} bundle exec cap #{@task_argv.join(' ')}] } "
+    #   CMD
+    # end
+
     def generate_command
       <<-CMD
       #{cd_working_directory} && RAILS_ENV=#{@env_name} bundle exec multi_cap #{@task_argv.join(' ')}

data/lib/capistrano_multiconfig_parallel/cli.rb

@@ -3,15 +3,22 @@ Gem.find_files('capistrano_multiconfig_parallel/extensions/**/*.rb').each { |pat
 module CapistranoMulticonfigParallel
   # this is the class that will be invoked from terminal , and willl use the invoke task as the primary function.
   class CLI
+    # method used to start
     def self.start
       CapistranoMulticonfigParallel.check_terminal_tty
       CapistranoMulticonfigParallel.original_args = ARGV.dup
-      CapistranoMulticonfigParallel::Application.new.run
+      job_manager = CapistranoMulticonfigParallel::Application.new
+      if job_manager.can_start?
+        job_manager.start
+      else
+        Capistrano::Application.new.run
+      end
     rescue Interrupt
       `stty icanon echo`
       $stderr.puts 'Command cancelled.'
     rescue => error
       $stderr.puts error
+      $stderr.puts error.backtrace if error.respond_to?(:backtrace)
       exit(1)
     end
   end

data/lib/capistrano_multiconfig_parallel/configuration.rb

@@ -8,15 +8,16 @@ module CapistranoMulticonfigParallel
 
       def configuration
         @config ||= Configliere::Param.new
-        @config.use :commandline
         command_line_params.each do |param|
-          @config.define param[:name], type: param[:type], description: param[:description], default: param[:default]
+          param_type = change_config_type(param['type'].to_s)
+          @config.define param['name'], type: param_type, description: param['description'], default: param['default']
         end
 
         ARGV.clear
+
         CapistranoMulticonfigParallel.original_args.each { |a| ARGV << a }
         @config.read config_file if File.file?(config_file)
-        @config.merge(Settings.use(:commandline).resolve!)
+        @config.use :commandline
 
         @config.use :config_block
         @config.finally do |c|
@@ -34,30 +35,14 @@ module CapistranoMulticonfigParallel
       end
 
       def command_line_params
-        @default_config ||= Configliere::Param.new
-        @default_config.read File.join(internal_config_directory, 'default.yml')
-        @default_config.resolve!
-        @default_config[:default_config].map do |item|
-          item[:type] = change_config_type(item[:type].to_s)
-          item
-        end
+        @default_config ||= YAML.load_file(File.join(internal_config_directory, 'default.yml'))['default_config']
+        @default_config
       end
 
       def change_config_type(type)
-        type.include?(':') ? type.delete(':').to_sym : type.constantize
+        ['boolean'].include?(type) ? type.delete(':').to_sym : type.constantize
       end
 
-      def capistrano_options
-        command_line_params.map do |param|
-          [
-            "--#{param[:name]}[=CAP_VALUE]",
-            "--#{param[:name]}",
-            "[MULTI_CAP] #{param[:description]}. By default #{param[:default]}",
-            lambda do |_value|
-            end
-          ]
-        end
-      end
 
       def verify_array_of_strings(value)
         return true if value.blank?
@@ -80,13 +65,7 @@ module CapistranoMulticonfigParallel
         end
       end
 
-      def verify_app_dependencies(stages)
-        applications = stages.map { |stage| stage.split(':').reverse[1] }
-        wrong = configuration.application_dependencies.find do |hash|
-          !applications.include?(hash[:app]) || (hash[:dependencies].present? && hash[:dependencies].find { |val| !applications.include?(val) })
-        end
-        raise ArgumentError, "invalid configuration for #{wrong.inspect}" if wrong.present?
-      end
+
 
       def check_boolean(c, prop)
         raise ArgumentError, "the property `#{prop}` must be boolean" unless %w(true false).include?(c[prop].to_s.downcase)
@@ -94,7 +73,6 @@ module CapistranoMulticonfigParallel
 
       def configuration_valid?(stages)
         configuration
-        verify_app_dependencies(stages) if configuration.application_dependencies.present?
       end
 
       def check_boolean_props(c, props)

data/lib/capistrano_multiconfig_parallel/extensions/rake.rb

@@ -1,4 +1,4 @@
-require_relative './rake_hook_actor'
+require_relative '../helpers/rake_hook_actor'
 Rake::Task.class_eval do
   alias_method :original_execute, :execute
 

data/lib/capistrano_multiconfig_parallel/{multi_app_helpers → helpers}/dependency_tracker.rb

@@ -68,8 +68,8 @@ module CapistranoMulticonfigParallel
 
     def check_app_dependency_unique(applications_selected, apps_dependencies, applications_to_deploy, action)
       return applications_to_deploy if applications_selected.blank? || apps_dependencies.blank? || (apps_dependencies.map { |app| app['app'] } - applications_to_deploy.map { |app| app['app'] }).blank?
-      set :apps_dependency_confirmation, CapistranoMulticonfigParallel.ask_confirm("Do you want to  #{action} all dependencies also ?", 'Y/N')
-      applications_to_deploy = applications_to_deploy.concat(apps_dependencies) if fetch(:apps_dependency_confirmation).present? && fetch(:apps_dependency_confirmation).downcase == 'y'
+      apps_dependency_confirmation = CapistranoMulticonfigParallel.ask_confirm("Do you want to  #{action} all dependencies also ?", 'Y/N')
+      applications_to_deploy = applications_to_deploy.concat(apps_dependencies) if apps_dependency_confirmation.present? && apps_dependency_confirmation.downcase == 'y'
       applications_to_deploy
     end
 
@@ -102,10 +102,10 @@ module CapistranoMulticonfigParallel
 
     def print_frameworks_used(app_names, applications_to_deploy, action)
       app_names.each { |app| puts "#{app}" }
-      set :apps_deploy_confirmation, CapistranoMulticonfigParallel.ask_confirm("Are you sure you want to #{action} these apps?", 'Y/N')
-      if fetch(:apps_deploy_confirmation).blank? || (fetch(:apps_deploy_confirmation).present? && fetch(:apps_deploy_confirmation).downcase != 'y')
+      apps_deploy_confirmation = CapistranoMulticonfigParallel.ask_confirm("Are you sure you want to #{action} these apps?", 'Y/N')
+      if apps_deploy_confirmation.blank? || (apps_deploy_confirmation.present? && apps_deploy_confirmation.downcase != 'y')
         return []
-      elsif fetch(:apps_deploy_confirmation).present? && fetch(:apps_deploy_confirmation).downcase == 'y'
+      elsif apps_deploy_confirmation.present? && apps_deploy_confirmation.downcase == 'y'
         return applications_to_deploy
       end
     end

data/lib/capistrano_multiconfig_parallel/helpers/helper.rb

@@ -0,0 +1,9 @@
+module Helper
+
+  module_function
+
+  def find_loaded_gem(name)
+    Gem.loaded_specs.values.detect{|repo| repo.name == name }
+  end
+
+end

data/lib/capistrano_multiconfig_parallel/{extensions → helpers}/rake_hook_actor.rb

@@ -1,4 +1,3 @@
-require 'celluloid/autostart'
 require_relative '../celluloid/rake_worker'
 require_relative './input_stream'
 require_relative './output_stream'

data/lib/capistrano_multiconfig_parallel/initializers/conf.rb

@@ -1,11 +1,10 @@
-require 'configliere'
 require 'configliere/commandline'
 Configliere::Commandline.class_eval do
   def resolve!(print_help_and_exit = true)
     process_argv!
-    if print_help_and_exit && self[:multi_help]
+    if print_help_and_exit && self[:help]
       dump_help
-      exit(2)
+    #  exit(2)
     end
     super()
     self

data/lib/capistrano_multiconfig_parallel/initializers/default.yml

@@ -1,18 +1,18 @@
 default_config:
   - name: 'multi_debug'
-    type: ':boolean'
+    type: 'boolean'
     description: >-
       Enable debugging of workers, CAP_VALUE can be true or false
     default: TRUE
 
   - name: 'multi_secvential'
-    type: ':boolean'
+    type: 'boolean'
     description: >-
       Forces execution of jobs in sequence, CAP_VALUE can be true or false
     default: false
 
   - name: 'websocket_server.enable_debug'
-    type: ':boolean'
+    type: 'boolean'
     description: >-
       Enables debugging of websocket communication between the workers,
       CAP_VALUE can be true or false

data/lib/capistrano_multiconfig_parallel/version.rb

@@ -7,8 +7,8 @@ module CapistranoMulticonfigParallel
   # module used for generating the version
   module VERSION
     MAJOR = 0
-    MINOR = 15
-    TINY = 6
+    MINOR = 16
+    TINY = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')