dply 0.0.2

data/dply.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dply/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dply"
+  spec.version       = Dply::VERSION
+  spec.authors       = ["Neeraj"]
+  spec.summary       = %q{rake based deploy tool}
+  spec.description   = %q{rake based deploy tool}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/dply.rb

@@ -0,0 +1,5 @@
+require "dply/version"
+
+module Dply
+  # Your code goes here...
+end

data/lib/dply/cli/deploy.rb

@@ -0,0 +1,69 @@
+require 'dply/deploy'
+require 'dply/logger'
+require 'dply/lock'
+
+module Dply
+  module Cli
+    class Deploy
+
+      include Logger
+
+      attr_reader :deploy_dir, :argv
+
+      def initialize(deploy_dir, argv)
+        @deploy_dir = deploy_dir
+        @argv = argv
+      end
+
+      def run
+        lock.acquire
+        opts.parse!(argv)
+        target = argv.shift
+        deploy.config.target = target if target
+        deploy.options = options
+        deploy.run
+      end
+
+      def deploy
+        @deploy ||= ::Dply::Deploy.new(deploy_dir)
+      end
+
+      def lock
+        @lock ||= ::Dply::Lock.new(deploy_dir)
+      end
+
+      def opts
+        OptionParser.new do |opts|
+
+          opts.banner = "Usage: dply deploy [options] [target]"
+          
+          opts.on("-b", "--branch [BRANCH]" , "Specify git branch") do |b|
+            options[:branch] = b
+          end
+
+          opts.on("--no-pull", "Enable/disable git pull") do |e|
+            options[:no_pull] = true
+          end
+
+          opts.on("--skip-git", "Disable git") do |e|
+            options[:skip_git] = true
+          end  
+          
+          opts.on("--skip-bundler", "Skip bundle install") do |e|
+            options[:skip_bundler] = true
+          end
+
+          opts.on("-h", "--help", "Help") do
+            puts opts
+            exit
+          end
+        end
+      end
+
+      def options
+        @options ||= {}
+      end
+
+    end
+  end
+end

data/lib/dply/config.rb

@@ -0,0 +1,102 @@
+require 'ostruct'
+require 'dply/helper'
+
+module Dply
+  class Config
+
+    include Helper
+    attr_reader :deploy_dir, :config_file_required
+
+    def initialize(deploy_dir, config_file_required: true)
+      @deploy_dir = deploy_dir
+      @config_file_required = config_file_required
+    end
+
+    def config
+      return @config if @config
+      @config = {
+        deploy_dir: deploy_dir,
+        target: :default,
+        branch: :master,
+        strategy: :default,
+        repo: nil,
+        env: {},
+        link_config: false,
+        config_map: nil,
+        dir_map: nil,
+        shared_dirs: []
+      }
+      read_from_file
+      return @config
+    end
+
+    def target(target)
+      set :target, target
+    end
+
+    def branch(branch)
+      set :branch, branch
+    end
+
+    def strategy(strategy)
+      set :strategy, strategy
+    end
+
+    def repo(repo)
+      set :repo, repo
+    end
+
+    def link_config(link_config)
+      set :link_config, link_config
+    end
+
+    def config_map(map)
+      set :link_config, true
+      set :config_map, map
+    end
+
+    def dir_map(map)
+      set :dir_map, map
+    end
+
+    def set_env(key, value)
+      @config[:env].store key, value
+    end
+
+    def set(key, value)
+      @config.store key, value
+    end
+
+    def to_struct
+      OpenStruct.new(config)
+    end
+
+    def env(h)
+      raise if not h.is_a? Hash
+      @config[:env] = h
+      @config[:env].each do |k,v|
+        ENV[k.to_s] = v.to_s
+      end
+    end
+
+    def config_file
+      @config_file ||= "#{deploy_dir}/dply.rb"
+    end
+
+    def shared_dirs(dirs)
+      raise if not dirs.is_a? Array
+      @config[:shared_dirs] = dirs
+    end
+
+    def read_from_file
+      if not File.readable? config_file
+        raise error "dply.rb not found in #{deploy_dir}"  if config_file_required
+        return
+      end
+      instance_eval(File.read(config_file))
+    rescue NoMethodError => e
+      raise error "invalid option used in config: #{e.name}"
+    end
+
+  end
+end

data/lib/dply/custom_logger.rb

@@ -0,0 +1,29 @@
+require 'logger'
+require 'dply/ext/string'
+module Dply
+  class CustomLogger < ::Logger
+
+    def initialize(file)
+      super(file)
+      @level = ::Logger::INFO
+    end
+
+    def format_message(severity, timestamp, progname, msg)
+      case severity
+      when "INFO"
+        "#{msg}\n"
+      when "ERROR"
+        "#{severity.bold.red} #{msg}\n"
+      when "WARN"
+        "#{severity.downcase.bold.yellow} #{msg}\n"
+      else
+        "#{severity.downcase.bold.blue} #{msg}\n"
+      end
+    end
+
+    def bullet(msg)
+      puts "#{"\u2219".bold.blue} #{msg}"
+    end
+
+  end
+end

data/lib/dply/deploy.rb

@@ -0,0 +1,33 @@
+require 'dply/setup'
+require 'dply/strategy'
+require 'dply/config'
+
+module Dply
+  class Deploy
+
+    attr_reader :deploy_dir
+    attr_writer :options
+
+    def initialize(deploy_dir)
+      @deploy_dir = deploy_dir
+    end
+
+    def run
+      strategy.deploy
+    end
+
+    def config
+      @config ||= Config.new(deploy_dir).to_struct
+    end
+
+    def strategy
+      @strategy ||= Strategy.load(config, options)
+    end
+
+    def options
+      @options ||= {}
+    end
+
+
+  end
+end

data/lib/dply/dplyr.rb

@@ -0,0 +1,45 @@
+require 'dply/stages_config'
+require 'dply/remote_task'
+module Dply
+  class Dplyr
+
+    attr_reader :stage, :argv
+    def initialize(stage, argv)
+      @stage = stage
+      @argv = argv
+    end
+
+    def run
+      case stage
+      when 'dev'
+        system "drake #{argv_str}"
+      when 'local'
+        system "drake #{argv_str}"
+      else
+        run_remote_task
+      end
+    end
+
+    def stage_data
+      @stage_data ||= StagesConfig.new("stages.rb").get_stage(stage)
+    end
+
+    def hosts
+      stage_data[:hosts]
+    end
+
+    def parallel_jobs
+      stage_data[:parallel_runs]
+    end
+
+    def argv_str
+      @argv_str ||= argv.join(' ')
+    end
+
+    def run_remote_task
+      remote_task = ::Dply::RemoteTask.new(hosts, argv_str, parallel_jobs: parallel_jobs)
+      remote_task.run
+    end
+
+  end
+end

data/lib/dply/error.rb

@@ -0,0 +1,4 @@
+module Dply
+  class Error < StandardError
+  end
+end

data/lib/dply/ext/string.rb

@@ -0,0 +1,33 @@
+class String
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end 
+
+  def bold
+    "\e[1m#{self}\e[0m"
+  end 
+  
+  def white
+    colorize(37)
+  end 
+
+  def green
+    colorize(32)
+  end 
+
+  def yellow
+    colorize(33)
+  end 
+
+  def red 
+    colorize(31)
+  end 
+
+  def blue
+    colorize(34)
+  end 
+
+  def grey
+    colorize("90")
+  end
+end

data/lib/dply/git.rb

@@ -0,0 +1,43 @@
+require 'dply/shell'
+module Dply
+  module Git
+
+    extend Shell
+
+    def self.pull(branch)
+      cmd "git fetch"
+      checkout(branch)
+      if tracking_branch = get_tracking_branch(branch)
+        cmd "git merge #{tracking_branch}"
+      else
+        cmd "git pull origin #{branch}"
+      end
+    end
+  
+    def self.checkout(branch)
+      current_branch = `git rev-parse --abbrev-ref HEAD `.chomp.to_sym
+      cmd "git checkout #{branch}" if branch != current_branch
+    end
+
+    def self.clone(repo, dir, mirror: nil)
+      cmd "git clone #{repo} #{dir}"
+    end
+
+    def self.get_tracking_branch(branch)
+      command = "git for-each-ref --format='%(upstream:short)' refs/heads/#{branch} --count=1"
+      tracking_branch = `#{command}`
+      if tracking_branch =~ /[a-zA-Z0-9_]/
+        return tracking_branch.chomp!
+      else
+        return nil
+      end  
+    end
+
+    def self.get_remote_url
+     remote_url = cmd "git config --get remote.origin.url", return_output: true, display: false
+     logger.debug remote_url.chomp
+     remote_url.chomp
+    end
+
+  end
+end

data/lib/dply/helper.rb

@@ -0,0 +1,35 @@
+require 'dply/tasks'
+require 'dply/shell'
+require 'dply/git'
+require 'dply/error'
+require 'dply/logger'
+
+
+module Dply
+  module Helper
+
+    def self.git
+      Git
+    end
+
+    def self.tasks
+      @tasks ||= Tasks.new
+    end
+
+    include Shell
+    include Logger
+
+    def git
+      ::Dply::Helper.git
+    end
+
+    def tasks
+      ::Dply::Helper.tasks
+    end
+
+    def error(msg)
+      ::Dply::Error.new(msg)
+    end
+
+  end
+end

data/lib/dply/linker.rb

@@ -0,0 +1,71 @@
+require 'dply/helper'
+module Dply
+  class Linker
+
+    include Helper
+
+    attr_reader :src_dir, :dest_dir, :map, :dir_prefix
+
+    def initialize(src_dir, dest_dir, map: nil, dir_prefix: nil)
+      verify_absolute src_dir, dest_dir
+      @src_dir = src_dir
+      @dest_dir = dest_dir
+      @map = map
+      @dir_prefix = dir_prefix
+    end
+    
+    def create_symlinks
+      files.each do |f|
+        link_target = link_target(f)
+        absolute_source_path = absolute_source_path(f)
+        relative_path = absolute_source_path.relative_path_from link_target.parent
+        logger.debug "linking #{link_target} -> #{absolute_source_path}"
+        symlink(relative_path, link_target)
+      end
+    end
+
+    def files
+      @map ? mapped_files : all_files
+    end
+
+    def map
+      @map || default_map
+    end
+
+    def link_target(relative_source)
+      target = map[relative_source]
+      Pathname.new "#{dest_dir}/#{target}"
+    end
+
+    def absolute_source_path(src)
+      Pathname.new "#{src_dir}/#{src}"
+    end
+
+
+    def default_map
+      @h ||= Hash.new do |hash, key|
+        dir_prefix ? "#{dir_prefix}/#{key}" : "#{key}"
+      end
+    end
+
+    def all_files
+      Dir.chdir(src_dir) { Dir.glob("*") }
+    end
+    
+    def mapped_files
+      map.keys.collect do |k|
+        path = Pathname.new k 
+        raise "config map path cannot be absoulte" if path.absolute?
+        k
+      end
+    end
+
+    def verify_absolute(*paths)
+      paths.each do |path|
+        absolute = Pathname.new(path).absolute?
+        raise "#{path} not absolute" if not absolute
+      end
+    end
+
+  end
+end