dply 0.0.5 → 0.0.7

data/lib/dply/git.rb

@@ -23,6 +23,11 @@ module Dply
       cmd "git clone #{repo} #{dir}"
     end
 
+    def self.clean
+      cmd "git reset --hard HEAD"
+      cmd "git clean -dxf "
+    end
+
     def self.get_tracking_branch(branch)
       command = "git for-each-ref --format='%(upstream:short)' refs/heads/#{branch} --count=1"
       tracking_branch = `#{command}`

data/lib/dply/helper.rb

@@ -2,7 +2,6 @@ require 'dply/tasks'
 require 'dply/shell'
 require 'dply/git'
 require 'dply/error'
-require 'dply/logger'
 
 
 module Dply
@@ -12,23 +11,14 @@ module Dply
       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)
+      raise ::Dply::Error, msg
     end
 
   end

data/lib/dply/jenkins.rb

@@ -0,0 +1,32 @@
+require 'open-uri'
+require 'json'
+require 'dply/helper'
+
+module Dply
+  class Jenkins
+
+    include Helper
+
+    def initialize(url, project)
+      @url = URI.parse(url)
+      @project = project
+      validate
+    end
+
+    def latest_successful_revision
+      api_url = "#{@url}/job/#{@project}/api/json"
+      logger.debug "using jenkins api \"#{api_url}\""
+      open(api_url) do |f|
+        json = JSON.parse(f.read)
+        revision = json["lastSuccessfulBuild"]["number"]
+        logger.debug "got revision #{revision}"
+        revision
+      end
+    end
+
+    def validate
+      raise "invalid uri " if not ["http", "https"].include? @url.scheme
+      raise "project name not defined" if not @project
+    end
+  end
+end

data/lib/dply/lock.rb

@@ -1,23 +1,27 @@
-require 'dply/helper'
+require 'dply/logger'
 module Dply
   class Lock
 
-    include Helper
-    attr_accessor :deploy_dir
+    include Logger
 
-    def initialize(deploy_dir)
-      @deploy_dir = deploy_dir
+    def initialize(dir = nil)
+      @dir = dir
+    end
+
+    def acquire
+      logger.debug "acquiring lock"
+      lock_acquired = lock_file.flock(File::LOCK_NB | File::LOCK_EX)
+      raise "exclusive lock not available" if not lock_acquired
     end
 
     def lock_file
-      @lock_file ||= Dir.chdir(deploy_dir) do
-        File.open(".dply.lock", "w+")
-      end
+      @lock_file ||= File.open("#{dir}/.dply.lock", "a+")
     end
 
-    def acquire
-      logger.debug "acquiring exclusive lock"
-      lock_file.flock(File::LOCK_EX)
+    private
+
+    def dir
+      @dir ||= Dir.pwd
     end
 
   end

data/lib/dply/release.rb

@@ -1,33 +1,75 @@
+require 'dply/archive'
+require 'dply/helper'
+require 'tmpdir'
+
 module Dply
   class Release
 
-    attr_reader release_dir
+    include Helper
+
+    attr_accessor :url, :verify_checksum
+    attr_reader :name
+
+    def initialize(revision, app_name: nil, branch: nil, url: nil)
+      @revision = revision
+      @branch = branch
+      @app_name = app_name
+      @url = url
+    end
+
+    def make_current
+      raise "cannot make not installed release current" if not installed?
+      raise "release path #{path} doesn't exist"  if not File.directory? path
+      symlink path, "current"
+    end
+
+    def install
+      return if installed?
+      @name = name_without_ts + timestamp
+      Dir.mktmpdir "tmp" do |d|
+        path = "#{d}/#{name}"
+        archive.extract_to path
+        FileUtils.mv path, "releases"
+      end
+      @installed = true
+      archive.clean
+    end
+
+    def path
+      @path ||= "releases/#{@name}"
+    end
+
+    private
 
-    def initialize(release_dir)
-      @release_dir = release_dir
+    def replace_dashes(str)
+      str.to_s.gsub(/-/, "_")
     end
 
-    def create(repo_cache, branch)
-      return if exists?
-      FileUtils.mkdir uncommited_release_dir
-      copy_source_code(repo_cache, branch)
+    def archive
+      @archive ||= Archive.new(url, verify_checksum: @verify_checksum)
     end
 
-    def copy_source_code(repo_cache, branch)
-      cmd "git archive #{branch} | tar -x -f - -C  #{uncommited_release_dir}"
+    def timestamp
+      Time.now.strftime "%Y%m%d%H%M%S"
     end
 
-    def exists?
-      File.exists? (release_dir) || File.exists? (uncommited_release_dir)
+    def load_status
+      name = name_without_ts
+      latest = Dir["releases/#{name}*"].sort_by { |x, y| File.mtime(x) }.first
+      if latest
+        @installed = true
+        @name = File.basename latest
+      end
+      @status_loaded = true
     end
 
-    def uncommited_release_dir
-      "#{release_dir}.uncommited"
+    def installed?
+      load_status if not @status_loaded
+      @installed
     end
 
-    def commit
-      return if File.exists? (release_dir)
-      FileUtils.mv uncommited_release_dir, release_dir
+    def name_without_ts
+      @name_without_ts ||= "#{@revision}-#{replace_dashes(@app_name)}-#{replace_dashes(@branch)}-"
     end
 
   end

data/lib/dply/setup.rb

@@ -1,11 +1,52 @@
+require 'fileutils'
+require 'dply/helper'
+require 'dply/repo'
+require 'dply/shared_dirs'
+
 module Dply
-  module Setup
+  class Setup
+
+    include Helper
+
+    def initialize(config)
+      @config = config
+    end
+
+    def build
+      dirs = ["config", "shared", "build"]
+      create_repo if @config.git
+      create_dirs dirs
+      create_shared_dirs
+    end
+
+    def git
+      dirs = ["config", "shared"]
+      create_repo
+      symlink "repo", "current"
+      create_dirs dirs
+      create_shared_dirs
+    end
+
+    def archive
+      dirs = ["config", "shared", "releases", "tmp/cache"]
+      create_dirs dirs
+      create_shared_dirs
+    end
+
+    private
+
+    def create_repo
+      repo = ::Dply::Repo.new("repo", @config.repo)
+      repo.create
+    end
+
+    def create_dirs(dirs)
+      FileUtils.mkdir_p dirs
+    end
 
-    def self.load(strategy, config)
-      require_relative "setup/#{strategy}"
-      const = "::Dply::Setup::#{strategy.capitalize}"
-      const = Module.const_get(const)
-      return const.new(config)
+    def create_shared_dirs
+      shared_dirs = SharedDirs.new(@config.shared_dirs)
+      shared_dirs.create_in "shared"
     end
 
   end

data/lib/dply/shell.rb

@@ -1,4 +1,5 @@
 require 'dply/error'
+require 'dply/logger'
 
 module Dply
   module Shell
@@ -12,11 +13,13 @@ module Dply
       else
         logger.debug command
       end
+      command_arr = command.split
+
       if return_output
-        output = `#{env_str(env)} #{command}`
+        output = IO.popen(env, command_arr) { |f| f.read }
       else
         output = ""
-        system env, "#{command} 2>&1"
+        system(env, *command_arr, 2 => 1)
       end 
       return_value = $?.exitstatus
       error_msg ||= "non zero exit for \"#{command}\""
@@ -44,14 +47,6 @@ module Dply
       symlink src, dst
     end
 
-    def env_str(env)
-      str = ""
-      env.each do |k,v|
-        str << %(#{k}="#{v.to_s}")
-      end
-      str
-    end
-
     def stringify_values(hash)
       hash.each do |k,v|
         hash[k] = v.to_s

data/lib/dply/stages_config.rb

@@ -90,12 +90,12 @@ module Dply
 
     def read_from_file
       if not File.readable? config_file
-        raise error "#{config_file} not readable"
+        error "#{config_file} not readable"
         return
       end
       instance_eval(File.read(config_file), config_file)
     rescue NoMethodError => e
-       raise "invalid option used in config: #{e.name} #{e.message}"
+       error "invalid option used in config: #{e.name} #{e.message}"
     end
 
 

data/lib/dply/strategy/archive.rb

@@ -0,0 +1,124 @@
+require 'dply/helper'
+require 'dply/setup'
+require 'dply/linker'
+require 'dply/config_downloader'
+require 'dply/yum'
+require 'dply/release'
+require 'forwardable'
+
+
+module Dply
+  module Strategy
+    class Archive
+      
+      extend Forwardable
+      include Helper
+
+      attr_reader :config, :options
+      def_delegators :config, :target, :branch, :revision, :name,
+                     :config_map, :dir_map, :config_skip_download,
+                     :config_download_url, :build_url
+                
+      def initialize(config, options)
+        @config = config
+        @options = options || {}
+      end
+
+      def deploy
+        setup.archive
+        download_configs if config_download_url
+        install_release
+        release.make_current
+        previous_version = get_release
+        Dir.chdir current_dir do
+          tasks.deploy target
+        end
+        current_version = get_release
+        tasks.report_changes(previous_version, current_version)
+      end
+      
+      def reload
+        download_configs if config_download_url
+        Dir.chdir current_dir do
+          link_dirs
+          link_config
+          tasks.reload target
+        end
+      end
+
+      private
+
+      def current_dir
+        @current_dir ||= "#{config.dir}/current"
+      end
+
+      def get_release
+        File.basename (File.readlink current_dir)
+      end
+
+      def download_configs
+        files = config_map.values.uniq
+        downloader = ConfigDownloader.new(files, config_download_url)
+        downloader.skip_download = config_skip_download 
+        downloader.download_all
+      end
+
+      def release
+        @release ||= Release.new(
+          revision, branch: branch,
+          app_name: config.name,
+          url: config.build_url
+        )
+      end
+
+      def install_release
+        release.verify_checksum = config.verify_checksum
+        release.install
+        Dir.chdir release.path do
+          link_dirs
+          link_config
+          yum_install
+        end
+      end
+
+      def yum_install
+        Yum.new("pkgs.yml").install
+      end
+
+      def git_step
+        return if options[:skip_git]
+        if options[:no_pull]
+          git.checkout branch
+        else
+          git.pull branch
+        end
+      end
+
+      def link_dirs
+        link "#{config.dir}/shared", dir_map
+      end
+
+      def link_config
+        link "#{config.dir}/config", config_map
+      end
+
+      def setup
+        @setup ||= Setup.new(@config)
+      end
+
+      def tasks
+        @tasks ||= Tasks.new(deployment: true)
+      end
+
+      def link(source, map)
+        return if not map
+        logger.bullet "symlinking #{source}"
+        dest = "#{config.dir}/#{release.path}"
+        linker = Linker.new(source, dest, map: map)
+        linker.create_symlinks
+      end
+
+
+    end
+  end
+end