dply 0.0.2

data/lib/dply/lock.rb

@@ -0,0 +1,24 @@
+require 'dply/helper'
+module Dply
+  class Lock
+
+    include Helper
+    attr_accessor :deploy_dir
+
+    def initialize(deploy_dir)
+      @deploy_dir = deploy_dir
+    end
+
+    def lock_file
+      @lock_file ||= Dir.chdir(deploy_dir) do
+        File.open(".dply.lock", "w+")
+      end
+    end
+
+    def acquire
+      logger.debug "acquiring exclusive lock"
+      lock_file.flock(File::LOCK_EX)
+    end
+
+  end
+end

data/lib/dply/logger.rb

@@ -0,0 +1,27 @@
+require 'logger'
+require 'dply/custom_logger'
+module Dply
+  module Logger
+
+    def self.logger
+      @logger ||= ::Dply::CustomLogger.new(STDOUT)
+    end
+
+    def self.stderr
+      @stderr ||= ::Logger.new(STDERR)
+    end
+
+    def logger
+      ::Dply::Logger.logger
+    end
+
+    def stderr
+      ::Dply::Logger.stderr
+    end
+
+    def debug?
+      logger.level == ::Logger::DEBUG
+    end
+
+  end
+end

data/lib/dply/release.rb

@@ -0,0 +1,34 @@
+module Dply
+  class Release
+
+    attr_reader release_dir
+
+    def initialize(release_dir)
+      @release_dir = release_dir
+    end
+
+    def create(repo_cache, branch)
+      return if exists?
+      FileUtils.mkdir uncommited_release_dir
+      copy_source_code(repo_cache, branch)
+    end
+
+    def copy_source_code(repo_cache, branch)
+      cmd "git archive #{branch} | tar -x -f - -C  #{uncommited_release_dir}"
+    end
+
+    def exists?
+      File.exists? (release_dir) || File.exists? (uncommited_release_dir)
+    end
+
+    def uncommited_release_dir
+      "#{release_dir}.uncommited"
+    end
+
+    def commit
+      return if File.exists? (release_dir)
+      FileUtils.mv uncommited_release_dir, release_dir
+    end
+
+  end
+end

data/lib/dply/remote_task.rb

@@ -0,0 +1,139 @@
+require 'pty'
+require 'dply/report'
+require 'dply/logger'
+
+module Dply
+  class RemoteTask
+
+    include Logger
+    
+    attr_reader :hosts, :parallel_jobs, :task
+
+    def initialize(hosts, task, parallel_jobs: 1)
+      @hosts = hosts
+      @parallel_jobs = parallel_jobs
+      @task = task
+    end
+
+    def run
+      if parallel_jobs > 1 && hosts.count > 1
+        run_in_parallel
+      else
+        run_serially
+      end
+    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
+      end
+    end
+
+    private
+
+    def init_run
+      queue_all_hosts
+      job_output_template
+      @threads = {}
+      @mq = Queue.new
+    end
+
+    def queue_all_hosts
+      @queue = Queue.new
+      hosts.each { |h| @queue << h }
+    end
+
+    def spawn_job(host_info)
+      run_cmd = remote_cmd host_info
+      thread = popen(run_cmd, host_info)
+      @threads[host_info] = thread
+    end
+
+    def spawn_queued_job
+      return if @queue.empty?
+      host = @queue.pop(false)
+      spawn_job host
+    rescue ThreadError
+    end
+
+    def remote_cmd(host_info)
+      user = host_info[:user]
+      host = host_info[:host]
+      deploy_dir = host_info[:deploy_dir]
+      if logger.debug?
+        %(ssh -tt -oBatchMode=yes -l #{user} #{host} "drake --debug -d #{deploy_dir} #{task} 2>&1")
+      else
+        %(ssh -tt -oBatchMode=yes -l #{user} #{host} "drake -d #{deploy_dir} #{task} 2>&1" 2>/dev/null)
+      end
+    end
+
+    def pty_read(file, id)
+      file.each do |line|
+        printf @job_output_template, id, line
+      end
+    rescue EOFError,Errno::ECONNRESET, Errno::EPIPE, Errno::EIO => e
+    end
+
+    def popen(cmd, host_info)
+      t = Thread.new do
+        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 report
+      @report ||= Report.new(hosts, exit_statuses)
+    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
+    end
+
+    def exit_status(pid)
+      pid, status = Process.waitpid2(pid)
+      return status
+    end
+
+  end
+end

data/lib/dply/repo.rb

@@ -0,0 +1,31 @@
+require 'dply/git'
+module Dply
+  class Repo
+
+    attr_reader :dir, :upstream, :mirror
+
+    def initialize(dir, upstream, mirror: nil)
+      @dir = dir
+      @upstream = upstream
+      @mirror = mirror
+    end
+
+    def create
+      if Dir.exist? "#{dir}/.git"
+        raise "unable to create repo" if not verify_remote_url
+      else
+        Git.clone upstream, dir 
+      end
+    end
+
+    private
+
+    def verify_remote_url
+      remote_url = Dir.chdir(dir) do
+        Git.get_remote_url
+      end
+      remote_url == upstream
+    end
+ 
+  end
+end

data/lib/dply/report.rb

@@ -0,0 +1,65 @@
+module Dply
+  class Report
+
+    attr_reader :hosts, :exit_statuses 
+
+    def initialize(hosts, exit_statuses)
+      @hosts = hosts
+      @exit_statuses = exit_statuses
+    end
+
+
+    def print_full
+      print_successful_jobs
+      print_failed_jobs
+      print_summary
+    end
+
+    def succeeded
+      @succeeded ||= exit_statuses.keys.select do |k|
+        exit_statuses[k] == 0
+      end
+    end
+
+    def failed
+      @failed ||= exit_statuses.keys.select do |k|
+        exit_statuses[k] != 0
+      end
+    end
+
+    def print_successful_jobs
+      puts "succeeded".green
+      succeeded.each do |host|
+        puts " - #{host[:id]}"
+      end
+    end
+
+    def print_failed_jobs
+      return if failed.count == 0
+      puts "failed".red
+      failed.each do |host|
+        puts " - #{host[:id]}"
+      end
+    end
+
+
+    def print_summary
+      total_hosts = hosts.count
+      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
+        failed_error = "failed on #{failed.count} of #{total_hosts} hosts" if failed.count > 0
+       
+        errors = []
+        errors << not_run_error if not_run_error
+        errors << failed_error if failed_error
+
+        error_str = "task #{errors.join(", ")}"
+        raise ::Dply::Error, error_str
+      end
+      puts "tasks ran successfully on #{succeeded.count}/#{total_hosts} hosts"
+    end
+
+  end
+end

data/lib/dply/setup.rb

@@ -0,0 +1,12 @@
+module Dply
+  module Setup
+
+    def self.load(strategy, config)
+      require_relative "setup/#{strategy}"
+      const = "::Dply::Setup::#{strategy.capitalize}"
+      const = Module.const_get(const)
+      return const.new(config)
+    end
+
+  end
+end

data/lib/dply/setup/default.rb

@@ -0,0 +1,31 @@
+require 'fileutils'
+require 'dply/helper'
+require 'dply/shared_dirs'
+
+module Dply
+  module Setup
+    class Default
+
+      include Helper
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def run
+        Dir.chdir config.deploy_dir do
+          shared_dirs.create
+        end
+      end
+
+      private
+
+      def shared_dirs
+        @shared_dirs ||= SharedDirs.new
+      end
+
+    end
+  end
+end

data/lib/dply/setup/git.rb

@@ -0,0 +1,52 @@
+require 'fileutils'
+require 'dply/helper'
+require 'dply/repo'
+require 'dply/shared_dirs'
+
+module Dply
+  module Setup
+    class Git
+
+      include Helper
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def run
+        Dir.chdir setup_dir do
+          repo.create
+          symlink "repo", "current"
+          create_dirs
+          shared_dirs.create_in "shared"
+        end
+      end
+
+      private
+
+      def repo
+        @repo ||= ::Dply::Repo.new(repo_dir, config.repo)
+      end
+
+      def create_dirs
+        dirs = ["config", "shared"]
+        FileUtils.mkdir_p dirs
+      end
+
+      def shared_dirs
+        @shared_dirs ||= SharedDirs.new(config.shared_dirs)
+      end
+
+      def setup_dir
+        config.deploy_dir
+      end
+
+      def repo_dir
+        "#{setup_dir}/repo"
+      end
+
+    end
+  end
+end

data/lib/dply/setup/release.rb

@@ -0,0 +1,58 @@
+require 'fileutils'
+require 'dply/helper'
+
+module Dply
+  class Setup
+
+    include Helper
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def run
+      method = "#{config.mode}_mode".to_sym
+      send method
+    end
+
+    def git_mode
+      Dir.chdir deploy_dir do
+        git.clone config.repo, "repo"
+        FileUtils.mkdir_p "config"
+        symlink "repo", "current"
+      end
+    end
+
+    def release_mode
+      Dir.chdir deploy_dir do
+        git.clone "repo_cache"
+        FileUtils.mkdir_p "shared", "releases", "config"
+        create_tmp_dirs "shared"
+        create_extra_shared_dirs "shared"
+      end
+    end
+
+    def default_mode
+      create_tmp_dirs deploy_dir
+    end
+
+    private
+
+    def create_tmp_dirs(dir)
+      dirs = "tmp/sockets", "tmp/pids", "log"
+      Dir.chdir(dir) { FileUtils.mkdir_p dirs }
+    end
+
+    def create_extra_shared_dirs(dir)
+      dirs = config.shared_dirs
+      Dir.chdir dir { FileUtils.mkdir_p dirs }
+    end
+
+    def deploy_dir
+      config.deploy_dir
+    end
+
+  end
+end