dply 0.1.13 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30096bb62002c6c0c805abbfbb25f21ee4257795
-  data.tar.gz: ac5a69f5bdd143e77e04e1755cd1098fe35ce2c7
+  metadata.gz: e36e026a2a88ee74042f732298e42fb7f13a4eca
+  data.tar.gz: b82102df075f09482830a6e48850710a6788b09a
 SHA512:
-  metadata.gz: 43a2fd54e8fea4a0ab99c48b9941b4a800bd23e9e4682880201544aadae1fd5fac51ccf66192f112d8faaf7142aeb8ab3ab82d87efca0f3e4fde2bc88abfa73e
-  data.tar.gz: 3768616031dd0f8516bd87fdd423a6239b8ce22a6d94be2e206ca766444ac18284bbec3011b2fff6e1772462a68a9f8e76c013a1621ada62376debf68fd7d185
+  metadata.gz: e0d0e00e407aab69f5394aad3dc2e8833c41db1c2869eff653f5dd396cb681f1fd017e8211bf7795c9f1ce9001fba5b5f8885b113844bf7eae9d66b89ec999e8
+  data.tar.gz: 27983c97231765d2b2387c02e1f234fd8b060fcd2652389047be8cbeeb05cbd1e19e98380b8de502d2db0161740067a2dc3ef691f6733c2972dcf0367f495991

data/bin/dplyr

@@ -45,10 +45,14 @@ opts_parser = OptionParser.new do |opts|
       logger.level = ::Logger::DEBUG
     end
 
+    opts.on("-m", "--enable-markers", "Enable marker logging") do
+      logger.enable_markers = true
+    end
+
     opts.on_tail("-h", "--help", "Show this message") do 
       puts opts
       exit
-    end 
+    end
 end
 begin
   opts_parser.order!(ARGV)
@@ -70,4 +74,8 @@ rescue OptionParser::InvalidOption, OptionParser::MissingArgument, ::Dply::Error
     logger.error "#{e.message}"
     abort
   end
+ensure
+  logger.marker "end"
 end
+
+

data/bin/drake

@@ -71,7 +71,9 @@ begin
 
   command = (ARGV.shift || "").to_sym
   case command
-  when :deploy, :reload, :task, :build, :depcheck, :"install-pkgs", :reopen_logs, :status
+  when :deploy, :reload, :task,
+       :build, :depcheck, :"install-pkgs", :reopen_logs,
+       :status, :devbuild, :setup
     run_cli command, ARGV
   when /\A[a-zA-Z_\-0-9]+[:][a-zA-Z_\-0-9]+\z/
     require 'dply/tasks'

data/docs/stages.rb

@@ -1,8 +1,13 @@
+#  Sample stages.rb
+# __________________________________________________________
+#
+
 stage :production do
   user "dev"
-  ask :user # exported to env as DPLY_USER
-  deploy_dir "/home/dev/project"
+  dir "/home/dev/project"
   parallel_runs 1
-  host "10.1.1.1", deploy_dir: "/home/dev/project1", id: "project1", user: "dev1"
-  host "10.1.1.2", deploy_dir: "/home/dev/project2", id: "project2"
+  host "10.1.1.1", dir: "/home/dev/project1", id: "project1", user: "dev1" ## default roles: ["first"]
+  host "10.1.1.2", dir: "/home/dev/project2", id: "project2"
+  host "10.1.1.3", roles: ["db"]
+  host "10.1.1.4"  ## default roles: ["last"]
 end

data/lib/dply/cli/devbuild.rb

@@ -0,0 +1,67 @@
+require 'dply/logger'
+require 'dply/lock'
+require 'dply/tasks'
+require 'fileutils'
+
+module Dply
+  module Cli
+    class Devbuild
+
+      include Logger
+
+      def initialize(argv)
+        @argv = argv
+        @options = {}
+      end
+
+      def run
+        lock.acquire
+        opts.parse!(@argv)
+        revision = @options[:revision] || "dev"
+        ENV["BUILD_NUMBER"] = revision
+
+        build_artifacts = "tmp/build_artifacts"
+        FileUtils.mkdir_p build_artifacts
+
+        clear_bundle_config
+        tasks.install_pkgs(build_mode: true, use_yum: @options[:use_yum])
+        tasks.build "build:default"
+      ensure
+        clear_bundle_config
+      end
+
+      def tasks
+        @tasks ||= ::Dply::Tasks.new
+      end
+
+      def lock
+        @lock ||= ::Dply::Lock.new
+      end
+
+      def clear_bundle_config
+        FileUtils.rm ".bundle/config" if File.exists? ".bundle/config"
+      end
+
+      def opts
+        OptionParser.new do |opts|
+
+          opts.banner = "Usage: drake devbuild [options] [target]"
+
+          opts.on("-r", "--revision [REVISION]", "Specify revision") do |r|
+            @options[:revision] = r
+          end
+
+          opts.on("--use-yum", "use yum to install packages") do |e|
+            @options[:use_yum] = true
+          end
+
+          opts.on("-h", "--help", "Help") do
+            puts opts
+            exit
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dply/cli/setup.rb

@@ -0,0 +1,102 @@
+require 'dply/logger'
+require 'dply/lock'
+require 'fileutils'
+require 'erb'
+
+module Dply
+  module Cli
+    class Setup
+
+      include ::Dply::Logger
+
+      def initialize(argv)
+        @argv = argv
+        @options = {}
+      end
+
+      def run
+        opts.parse!(@argv)
+        return if not proceed?
+        lock.acquire
+        setup_default
+        namespace = @argv.shift
+        if namespace
+          setup_task(namespace)
+        else
+          setup_build_task
+          setup_task(:production)
+        end
+      end
+
+      def proceed?
+        print "Are you sure?(y/n) "
+        v = STDIN.gets.strip
+        v == "y"
+      end
+
+      def setup_default
+        if not File.exist? "dply"
+          FileUtils.mkdir_p "dply"
+          logger.info "created dply/ dir"
+        else
+          logger.info "skipping dply/ dir"
+        end
+
+        rakefile = "dply/Rakefile"
+        if not File.exist? rakefile
+          FileUtils.touch rakefile
+          logger.info "created #{rakefile}"
+        else
+          logger.info "skipping #{rakefile}"
+        end
+        
+        pkgs_yml = "pkgs.yml"
+        if not File.exist? pkgs_yml
+          FileUtils.cp "#{templates_dir}/pkgs.erb", pkgs_yml
+          logger.info "created #{pkgs_yml}"
+        else
+          logger.info "skipping #{pkgs_yml}"
+        end
+      end
+
+      def setup_task(namespace, template: "deploy.erb")
+        tasks_file = "dply/#{namespace}.rake"
+        if File.exist? tasks_file
+          logger.info "skipping #{tasks_file}"
+          return
+        end
+        b = binding
+        template_path = "#{templates_dir}/#{template}"
+        erb = ERB.new(File.read(template_path), nil, '-')
+        File.open(tasks_file, 'w') { |f| f.write erb.result(b) }
+        logger.info "created #{tasks_file}"
+      end
+
+      def setup_build_task
+        setup_task("build", template: "build.erb")
+      end
+
+      def templates_dir
+        @templates_dir ||= "#{__dir__}/../templates"
+      end
+
+      def lock
+        @lock ||= ::Dply::Lock.new
+      end
+
+      def opts
+        OptionParser.new do |opts|
+
+          opts.banner = "Usage: drake setup [options] [namespace]"
+
+          opts.on("-h", "--help", "Help") do
+            puts opts
+            exit
+          end
+        end
+      end
+
+
+    end
+  end
+end

data/lib/dply/config.rb

@@ -33,6 +33,10 @@ module Dply
       set :repo, repo
     end
 
+    def mirror(repo)
+      set :mirror, repo
+    end
+
     def branch(branch)
       set :branch, branch
     end

data/lib/dply/config_struct.rb

@@ -4,7 +4,7 @@ module Dply
 
     attr_writer :revision, :build_url, :build_url_proc, 
                 :revision_proc
-    attr_accessor :dir, :name, :repo, :branch, 
+    attr_accessor :dir, :name, :repo, :branch, :mirror,
                   :strategy, :target, :verify_checksum, 
                   :config_map, :dir_map, :shared_dirs, 
                   :config_download_url, :config_skip_download 

data/lib/dply/custom_logger.rb

@@ -3,7 +3,7 @@ require 'dply/ext/string'
 module Dply
   class CustomLogger < ::Logger
 
-    attr_writer :trace_mode, :remote_mode
+    attr_writer :trace_mode, :remote_mode, :enable_markers
 
     def initialize(file)
       super(file)
@@ -37,5 +37,10 @@ module Dply
       puts %{dply_msg|#{msg}}
     end
 
+    def marker(msg)
+      return if not @enable_markers
+      puts "dply_marker:#{msg}"
+    end
+
   end
 end

data/lib/dply/git.rb

@@ -20,7 +20,12 @@ module Dply
     end
 
     def self.clone(repo, dir, mirror: nil)
-      cmd "git clone #{repo} #{dir}"
+      if mirror
+        cmd "git clone #{mirror} #{dir}"
+        Dir.chdir(dir) { cmd "git remote set-url origin #{repo}" }
+      else
+        cmd "git clone #{repo} #{dir}"
+      end
     end
 
     def self.clean

data/lib/dply/pkgs_config.rb

@@ -29,7 +29,7 @@ module Dply
         logger.debug "skipping yum pkgs"
         return {}
       end
-      YAML.safe_load(File.read(@pkgs_yml))
+      YAML.safe_load(File.read(@pkgs_yml)) || {}
     rescue => e
       error "error loading pkgs list" 
     end

data/lib/dply/repo.rb

@@ -14,7 +14,7 @@ module Dply
       if Dir.exist? "#{dir}/.git"
         raise "unable to create repo" if not verify_remote_url
       else
-        Git.clone upstream, dir 
+        Git.clone upstream, dir, mirror: @mirror
       end
     end
 

data/lib/dply/setup.rb

@@ -36,7 +36,7 @@ module Dply
     private
 
     def create_repo
-      repo = ::Dply::Repo.new("repo", @config.repo)
+      repo = ::Dply::Repo.new("repo", @config.repo, mirror: @config.mirror)
       repo.create
     end
 

data/lib/dply/tasks.rb

@@ -4,6 +4,8 @@ require 'dply/bundle'
 require 'dply/yum'
 require 'dply/linker'
 require 'dply/pkgs_config'
+require 'dply/error'
+require 'etc'
 
 module Dply
   class Tasks
@@ -49,9 +51,12 @@ module Dply
     def install_pkgs(build_mode: false, use_yum: false)
       return if not File.exists? "pkgs.yml"
       drake_exists = File.exists? (drake_command)
+
+      pkgs = get_pkgs(build_mode)
       if use_yum || !drake_exists
-        yum_install build_mode
+        yum_install pkgs
       else
+        return if Yum.new(pkgs).installed?
         command_install build_mode
       end
     end
@@ -70,20 +75,39 @@ module Dply
       @bundle ||= Bundle.new(deployment: @deployment)
     end
 
-    def yum_install(build_mode)
-      pkgs = PkgsConfig.new(build_mode: build_mode).pkgs
+    def get_pkgs(build_mode)
+      PkgsConfig.new(build_mode: build_mode).pkgs
+    end
+
+    def yum_install(pkgs)
       Yum.new(pkgs, sudo: true).install
     end
 
     def command_install(build_mode)
-      command = "sudo -n #{drake_command} install-pkgs"
+      command = "#{drake_command} install-pkgs"
       command << " -b" if build_mode
-      cmd command
+      check_sudo_permission command
+      cmd "sudo -n #{command}"
     end
 
     def drake_command
       @drake_command ||= (ENV["DRAKE_COMMAND"] || "/opt/ruby/bin/drake")
     end
 
+    def check_sudo_permission(command)
+      output = `sudo -n -l #{command}`
+      if output.chomp.strip == command
+        return true
+      else
+        msg = []
+        user = Etc.getpwuid(Process.uid).name
+        msg << %{unable to run "#{command}" with sudo permissions}
+        msg << %{To resolve add the following line to sudoers: }
+        msg << %{#{user} ALL=(ALL) NOPASSWD: /opt/ruby/bin/drake install-pkgs *, /opt/ruby/bin/drake install-pkgs}.yellow 
+        raise Error, msg.join("\n")
+      end
+
+    end
+
   end
 end

data/lib/dply/templates/build.erb

@@ -0,0 +1,5 @@
+namespace :build do
+  task :default do
+
+  end
+end

data/lib/dply/templates/deploy.erb

@@ -0,0 +1,15 @@
+namespace :<%= namespace %> do
+
+  task :deploy do
+
+  end
+
+  task :reload do
+
+  end
+
+  task :reopen_logs do
+
+  end
+  
+end

data/lib/dply/templates/pkgs.erb

@@ -0,0 +1,5 @@
+#pkgs:
+#  - postgresql94-libs
+# 
+# build_pkgs:
+#  - postgresql94-devel

data/lib/dply/version.rb

@@ -1,3 +1,3 @@
 module Dply
-  VERSION = "0.1.13"
+  VERSION = "0.1.17"
 end

data/lib/dply/yum.rb

@@ -26,6 +26,10 @@ module Dply
       end
     end
 
+    def installed?
+      not_installed_pkgs.size == 0
+    end
+
     private
 
     def pkgs_str
@@ -42,9 +46,5 @@ module Dply
       matches = `#{command}`.scan(/^package (.*) is not installed$/)
     end
 
-    def installed?
-      not_installed_pkgs.size == 0
-    end
-
   end
 end

data/lib/dplyr/cli.rb

@@ -1,5 +1,5 @@
 require 'dplyr/stages_config'
-require 'dplyr/remote_task'
+require 'dplyr/task_runner'
 require 'dply/logger'
 
 module Dplyr
@@ -52,8 +52,8 @@ module Dplyr
     end
 
     def run_remote_task
-      remote_task = RemoteTask.new(hosts, argv_str, parallel_jobs: parallel_jobs, env: env_str)
-      remote_task.run
+      task_runner  = TaskRunner.new(hosts, argv_str, parallel_jobs: parallel_jobs)
+      task_runner.run
     end
 
   end

data/lib/dplyr/remote_task.rb

@@ -6,85 +6,49 @@ module Dplyr
   class RemoteTask
 
     include ::Dply::Logger
-    
-    attr_reader :hosts, :parallel_jobs, :task, :env
 
-    def initialize(hosts, task, parallel_jobs: 1, env: "")
-      @hosts = hosts
-      @parallel_jobs = parallel_jobs
+    attr_reader :exit_status, :messages
+
+    def initialize(host, task, id_size: nil)
+      @host = host
       @task = task
-      @env = env
-      @env << " PATH=/usr/sbin:/usr/local/sbin:$PATH"
+      @messages = []
+      @id_size = id_size || @host_info[:id].size
     end
 
     def run
-      if parallel_jobs > 1 && hosts.count > 1
-        run_in_parallel
-      else
-        run_serially
-      end
+      reset!
+      r, w, pid = PTY.spawn(remote_cmd)
+      pty_read(r, @host[:id])
+      @exit_status = get_exit_status pid
     end
 
-    def run_in_parallel
-      init_run
-      parallel_jobs.times do
-        spawn_queued_job
-      end
-      loop do
-        break if @queue.empty?
-        @mq.pop
-        spawn_queued_job
-      end
-      report.print_full
-    end
-
-    def run_serially
-      hosts.each do |host_info|
-        puts "=== Running on #{host_info[:id]} ==="
-        run_cmd = remote_cmd host_info
-        system run_cmd
-        puts 
-        raise ::Dply::Error, "remote deploy failed on #{host_info[:id]}" if $? != 0
+    def remote_cmd
+      if logger.debug?
+        %(#{ssh} -l #{user} #{addr} '#{env} drake --remote --debug -d #{dir} #{@task} 2>&1')
+      else
+        %(#{ssh} -l #{user} #{addr} '#{env} drake --remote -d #{dir} #{@task} 2>&1' 2>/dev/null)
       end
     end
 
-    private
-
-    def init_run
-      queue_all_hosts
-      job_output_template
-      @threads = {}
-      @mq = Queue.new
+    def user
+      @host.fetch :user
     end
 
-    def queue_all_hosts
-      @queue = Queue.new
-      hosts.each { |h| @queue << h }
+    def dir
+      @host.fetch :dir
     end
 
-    def spawn_job(host_info)
-      run_cmd = remote_cmd host_info
-      thread = popen(run_cmd, host_info)
-      @threads[host_info] = thread
+    def addr
+      @host.fetch :addr
     end
 
-    def spawn_queued_job
-      return if @queue.empty?
-      host = @queue.pop(false)
-      spawn_job host
-    rescue ThreadError
+    def roles
+      @host.fetch :roles
     end
-
-    def remote_cmd(host_info)
-      user = host_info[:user]
-      host = host_info[:host]
-      dir = host_info[:dir]
-      ssh = "ssh -tt -o BatchMode=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
-      if logger.debug?
-        %(#{ssh} -l #{user} #{host} '#{env} drake --remote --debug -d #{dir} #{task} 2>&1')
-      else
-        %(#{ssh} -l #{user} #{host} '#{env} drake --remote -d #{dir} #{task} 2>&1' 2>/dev/null)
-      end
+    
+    def ssh
+      "ssh -tt -o BatchMode=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
     end
 
     def pty_read(file, id)
@@ -92,72 +56,42 @@ module Dplyr
         if line =~ /\Adply_msg\|/
           receive_message line
         else
-          printf @job_output_template, id, line
+          printf output_template, id, line
         end
       end
     rescue EOFError,Errno::ECONNRESET, Errno::EPIPE, Errno::EIO => e
     end
 
-    def popen(cmd, host_info)
-      t = Thread.new do |t|
-        Thread.current[:messages] = []
-        begin
-          r, w, pid = PTY.spawn(cmd)
-          pty_read(r, host_info[:id])
-          exit_status pid
-        ensure
-          @mq << true
-        end
-      end
-      t.abort_on_exception = true
-      t.run
-      return t
-    end
-
-    def host_id_max_width
-      hosts.map {|h| h[:id].size }.max
-    end
-
-    def job_output_template
-      @job_output_template ||= begin
-        id_template = "%-#{host_id_max_width}s".bold.grey
-        template = "#{id_template}  %s"
-      end
-    end
-
     def receive_message(msg_str)
       msg = msg_str.partition("|")[2].strip
       return if msg.empty?
-      messages = Thread.current[:messages]
-      messages << msg
+      @messages << msg
     end
 
-    def report
-      @report ||= Report.new(hosts, exit_statuses, messages)
+    def get_exit_status(pid)
+      pid, status = Process.waitpid2(pid)
+      return status
     end
 
-    def messages
-      @messages ||= begin
-        m = {}
-        @threads.each do |host, thread|
-          m[host] = thread[:messages]
-        end
-        m
+    def output_template
+      @output_template ||= begin
+        id_template = "%-#{@id_size}s".bold.grey
+        template = "#{id_template}  %s"
       end
     end
 
-    def exit_statuses
-      return @exit_statuses if @exit_statuses
-      @exit_statuses = {}
-      @threads.each do |host, thread|
-        @exit_statuses[host] = thread.value
-      end
-      @exit_statuses
+    def reset!
+      @output_template = nil
     end
 
-    def exit_status(pid)
-      pid, status = Process.waitpid2(pid)
-      return status
+    def env
+      @env ||= "PATH=/usr/sbin:/usr/local/sbin:$PATH #{roles_env}"
+    end
+
+    def roles_env
+      return "" if not roles.size > 0
+      roles_str = roles.join(",")
+      "DPLY_ROLES=#{roles_str}"
     end
 
   end

data/lib/dplyr/report.rb

@@ -1,6 +1,8 @@
+require 'dply/logger'
 module Dplyr
   class Report
 
+    include ::Dply::Logger
     attr_reader :hosts, :exit_statuses 
 
     def initialize(hosts, exit_statuses, messages)
@@ -11,6 +13,7 @@ module Dplyr
 
 
     def print_full
+      logger.marker "summary_start"
       print_successful_jobs
       print_failed_jobs
       print_summary
@@ -52,7 +55,7 @@ module Dplyr
       run_count = @exit_statuses.count
       not_run = total_hosts - run_count
       if (failed.count > 0 || not_run > 0 )
-        not_run_error = "not run on #{not_run}/#{total_hosts}" if not_run > 0
+        not_run_error = "not run on #{not_run} of #{total_hosts} hosts" if not_run > 0
         failed_error = "failed on #{failed.count} of #{total_hosts} hosts" if failed.count > 0
        
         errors = []

data/lib/dplyr/stage.rb

@@ -1,6 +1,10 @@
+require 'dply/helper'
+
 module Dplyr
   class Stage
 
+    include ::Dply::Helper
+
     attr_accessor :config_proc
 
     def initialize(name)
@@ -18,12 +22,13 @@ module Dplyr
       })
     end
 
-    def host(host, user: nil, dir: nil, id: nil)
+    def host(addr, user: nil, dir: nil, id: nil, roles: [])
       @hosts << ({
-        host: host,
+        addr: addr,
         user: user,
         dir: dir,
-        id: id || host
+        id: id || addr,
+        roles: cleaned_roles(roles)
       })
     end
 
@@ -54,15 +59,31 @@ module Dplyr
       return value
     end
 
+    def add_default_roles
+      return if not @hosts.size > 0
+      @hosts.first[:roles] << "first"
+      @hosts.last[:roles] << "last"
+    end
+
     def finalize
       return if @finalized
       instance_eval &config_proc if config_proc
       fill_hosts
+      add_default_roles
       @hosts.freeze
       @parallel_runs.freeze
       @finalized = true
     end
 
+    def cleaned_roles(roles)
+      error "roles must be an array" if not roles.is_a? Array
+      roles.each do |r|
+        r.strip!
+        error "invalid role value #{r} " if not r =~ /\A[0-9A-Za-z_\-]+\z/
+      end
+      return roles
+    end
+
   end
 end
 

data/lib/dplyr/task_runner.rb

@@ -0,0 +1,129 @@
+require 'dplyr/report'
+require 'dply/logger'
+require 'dplyr/remote_task'
+
+module Dplyr
+  class TaskRunner
+
+    include ::Dply::Logger
+    
+    attr_reader :hosts, :parallel_jobs, :task, :messages, :exit_statuses
+    attr_writer :auto_serialize
+
+    def initialize(hosts, task, parallel_jobs: 1)
+      @hosts = hosts
+      @parallel_jobs = parallel_jobs
+      @task = task
+
+      @messages = {}
+      @exit_statuses = {}
+      @auto_serialize = true
+    end
+
+    def run
+      if parallel_jobs > 1 && hosts.count > 1
+        run_in_parallel
+      else
+        run_serially
+      end
+      report.print_full
+    end
+
+    def run_serially
+      hosts.each do |host|
+        task = execute_serially host
+        break if task.exit_status != 0 
+      end
+    end
+
+    def run_in_parallel
+      if @auto_serialize
+        execute_serially hosts[0]
+        execute_in_parallel Range.new(1,hosts.size - 2)
+        execute_serially hosts[-1]
+      else
+        execute_in_parallel Range.new(0, hosts.size - 1)
+      end
+    end
+
+    private 
+
+    def remote_task(host)
+      RemoteTask.new(host, @task, id_size: host_id_max_width)
+    end
+
+    def execute_serially(host)
+      task = remote_task host
+      task.run
+      @exit_statuses[host] = task.exit_status
+      @messages[host] = task.messages
+      return task
+    end
+
+    def execute_in_parallel(range)
+      init_run
+      queue_hosts range
+      parallel_jobs.times do
+        spawn_queued_job
+      end
+      loop do
+        break if @queue.empty?
+        @mq.pop
+        spawn_queued_job
+      end
+      wait_for_threads
+    end
+
+    def start_task_thread(host)
+      t = Thread.new do
+        Thread.current[:messages] = []
+        task = remote_task(host)
+        begin
+          task.run
+          Thread.current[:messages] = task.messages
+          Thread.current[:exit_status] = task.exit_status
+        rescue => e
+          puts e.message
+        ensure
+          @mq << true
+        end
+      end
+      t.abort_on_exception = true
+      t.run
+      @threads[host] = t
+    end
+
+    def init_run
+      @mq = Queue.new
+      @queue = Queue.new
+      @threads = {}
+    end
+
+    def queue_hosts(range)
+      range.each { |i| @queue << hosts[i] }
+    end
+
+    def spawn_queued_job
+      return if @queue.empty?
+      host = @queue.pop(false)
+      start_task_thread host
+    rescue ThreadError
+    end
+
+    def host_id_max_width
+      @host_id_max_width ||= hosts.map {|h| h[:id].size }.max
+    end
+
+    def report
+      @report ||= Report.new(hosts, exit_statuses, messages)
+    end
+
+    def wait_for_threads
+      @threads.each do |host, t|
+        @exit_statuses[host] = t.value
+        @messages[host] = t[:messages]
+      end
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dply
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.17
 platform: ruby
 authors:
 - Neeraj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-13 00:00:00.000000000 Z
+date: 2015-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-elf
@@ -98,9 +98,11 @@ files:
 - lib/dply/cli/build.rb
 - lib/dply/cli/depcheck.rb
 - lib/dply/cli/deploy.rb
+- lib/dply/cli/devbuild.rb
 - lib/dply/cli/install_pkgs.rb
 - lib/dply/cli/reload.rb
 - lib/dply/cli/reopen_logs.rb
+- lib/dply/cli/setup.rb
 - lib/dply/cli/status.rb
 - lib/dply/cli/task.rb
 - lib/dply/config.rb
@@ -128,6 +130,9 @@ files:
 - lib/dply/strategy/archive.rb
 - lib/dply/strategy/git.rb
 - lib/dply/tasks.rb
+- lib/dply/templates/build.erb
+- lib/dply/templates/deploy.erb
+- lib/dply/templates/pkgs.erb
 - lib/dply/version.rb
 - lib/dply/yum.rb
 - lib/dplyr/cli.rb
@@ -135,6 +140,7 @@ files:
 - lib/dplyr/report.rb
 - lib/dplyr/stage.rb
 - lib/dplyr/stages_config.rb
+- lib/dplyr/task_runner.rb
 - lib/dplyr/tasks_config.rb
 homepage: ''
 licenses:
@@ -156,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: rake based deploy tool