docman 0.0.5 → 0.0.6

data/lib/docman/commands/command.rb

@@ -0,0 +1,137 @@
+require 'docman/logging'
+require 'docman/exceptions/command_validation_error'
+require 'docman/exceptions/no_changes_error'
+require 'hooks'
+
+module Docman
+
+  class Command < Hash
+
+    include Hooks
+    include Docman::Logging
+
+    attr_reader :type
+
+    @@subclasses = {}
+
+    define_hooks :before_execute, :after_execute
+
+    def self.create(params, context = nil, caller = nil)
+      c = @@subclasses[params['type']]
+      if c
+        c.new(params, context, caller)
+      else
+        raise "Bad command type: #{params['type']}"
+      end
+    end
+
+    def self.register_command(name)
+      @@subclasses[name] = self
+    end
+
+    def initialize(params = nil, context = nil, caller = nil, type = 'command')
+      unless params.nil?
+        params.each_pair do |k, v|
+          self[k] = v
+        end
+      end
+      @context = context
+      @caller = caller
+      @type = type
+      @log = self.has_key?('log') ? self['log'] : true
+      @hooks = {}
+    end
+
+    def config
+      add_actions self
+      add_actions @context unless @context.nil?
+    end
+
+    def add_actions(obj)
+      if obj.has_key? 'hooks' and obj['hooks'].has_key? @type
+        obj['hooks'][@type].each_pair do |name, hook|
+          if @hooks[name].nil?
+            @hooks[name] = hook
+          else
+            @hooks[name].concat(hook)
+          end
+        end
+      end
+    end
+
+    def add_action(name, hook)
+      if @hooks.has_key? name
+        @hooks[name] << {'type' => hook}
+      else
+        @hooks[name] = [hook]
+      end
+    end
+
+    def run_actions(name)
+      if @hooks.has_key? name
+        @hooks[name].each do |hook|
+          Docman::Command.create(hook, @context, self).perform
+        end
+      end
+    end
+
+    def run_with_hooks(method)
+       with_logging(method) do
+        run_hook "before_#{method}".to_sym
+        result = self.send(method)
+        @execute_result = result if method == 'execute'
+        run_hook "after_#{method}".to_sym
+      end
+    end
+
+    before_execute do
+      run_actions('before_execute')
+    end
+
+    # @abstract
+    def execute
+      raise NoMethodError.new("Please define #execute for #{self.class.name}", '')
+    end
+
+    after_execute do
+      run_actions('after_execute')
+    end
+
+    def perform
+      config if self.respond_to? :config
+      validate_command if self.respond_to? :validate_command
+      @execute_result = run_with_hooks('execute')
+    rescue CommandValidationError => e
+      logger.error "Command validation error: #{e.message}"
+      return false
+    rescue NoChangesError => e
+      logger.info "No changes: #{e.message}"
+      return false
+    rescue StandardError => e
+      logger.error e.message
+      raise
+    ensure
+      @execute_result
+    end
+
+    def describe(type = 'short')
+      "Command: #{properties_info}"
+    end
+
+    def prefix
+      prefix = []
+      prefix << @caller.prefix if not @caller.nil? and @caller.respond_to? :prefix
+      prefix << self.class.name
+      prefix.join(' - ')
+    end
+
+    def replace_placeholder(value)
+      value.gsub! '$ROOT$', @context['docroot_config'].root['full_build_path']
+      value.gsub! '$DOCROOT$', @context['docroot_config'].docroot_dir
+      value.gsub! '$PROJECT$', @context['full_build_path']
+      value.gsub! '$INFO$', @context['full_path']
+      value.gsub! '$ENVIRONMENT$', @context['docroot_config'].deploy_target['environment']
+    end
+
+  end
+end

data/lib/docman/commands/composite_command.rb

@@ -0,0 +1,28 @@
+module Docman
+  class CompositeCommand
+    def initialize(caller = nil)
+      @caller = caller
+      @commands = []
+    end
+
+    def add_command(cmd)
+      @commands << cmd
+    end
+
+    def add_commands(cmds, context = nil)
+      return if cmds.nil?
+      cmds.each do |k, v|
+        @commands << Docman::Command.create(k, v, context)
+      end
+    end
+
+    def perform
+      @commands.each { |cmd| cmd.perform }
+    end
+
+    def has_commands?
+      @commands.any?
+    end
+
+  end
+end

data/lib/docman/commands/create_symlink_cmd.rb

@@ -0,0 +1,24 @@
+require 'pathname'
+
+module Docman
+  class CreateSymlinkCmd < Docman::Command
+
+    register_command :create_symlink
+
+    def validate_command
+      raise "Please provide 'target_dir' param" if self['target_dir'].nil?
+      raise "Please provide 'context'" if @context.nil?
+      raise "Context should be of type 'Info'" unless @context.is_a? Docman::Info
+      raise "Directory #{File.join(@context['docroot_config'].docroot_dir, self['target_dir'])} not exists" unless File.directory? File.join(@context['docroot_config'].docroot_dir, self['target_dir'])
+    end
+
+    def execute
+      source_path = File.join(@context['docroot_config'].docroot_dir, self['target_dir'])
+      Dir.chdir source_path
+      source_pathname = Pathname.new source_path
+      target_pathname = Pathname.new @context['full_build_path']
+      relative_path = target_pathname.relative_path_from source_pathname
+      puts `ln -s #{relative_path} #{@context['name']}`
+    end
+  end
+end

data/lib/docman/commands/execute_script_cmd.rb

@@ -0,0 +1,40 @@
+
+module Docman
+  class ExecuteScriptCmd < Docman::Command
+
+    register_command :script
+
+
+    def validate_command
+      raise Docman::CommandValidationError.new("Please provide 'execution_dir' param") if self['execution_dir'].nil?
+      raise Docman::CommandValidationError.new("Please provide 'location' param") if self['location'].nil?
+      raise Docman::CommandValidationError.new("Please provide 'context'") if @context.nil?
+      raise Docman::CommandValidationError.new("Context should be of type 'Info'") unless @context.is_a? Docman::Info
+      replace_placeholder(self['execution_dir'])
+      replace_placeholder(self['location'])
+      raise Docman::CommandValidationError.new("Directory #{self['execution_dir']} not exists") unless File.directory? self['execution_dir']
+      raise Docman::CommandValidationError.new("Script #{self['location']} not exists") unless File.file? self['location']
+    end
+
+    def execute
+      Dir.chdir self['execution_dir']
+      logger.info "Script execution: #{self['location']}"
+      params = self['params'].nil? ? '' : prepare_params(self['params'])
+      `chmod a+x #{self['location']}`
+      logger.info `#{self['location']} #{params}`
+      $?.exitstatus
+    end
+
+    def prepare_params(params)
+      result = []
+      params.each do |param|
+        case param
+          when 'environment'
+            result << @context['docroot_config'].deploy_target['environment']
+        end
+      end
+      result.join(' ')
+    end
+
+  end
+end

data/lib/docman/commands/git_commit_cmd.rb

@@ -0,0 +1,25 @@
+module Docman
+  class GitCommitCmd < Docman::Command
+
+    register_command :git_commit
+
+    def validate_command
+      raise "Please provide 'context'" if @context.nil?
+      raise "Context should be of type 'Info'" unless @context.is_a? Docman::Info
+    end
+
+    before_execute do
+      unless GitUtil.repo_changed? @context['root']['full_build_path']
+        raise NoChangesError, "Repo not changed needed, commit not needed"
+      end
+      # @not_execute = true unless GitUtil.repo_changed? @context['root']['full_build_path']
+    end
+
+    def execute
+      message = "name: #{@context['name']} updated, state: #{@context['state']}"
+      with_logging(message) do
+        GitUtil.commit(@context['root']['full_build_path'], @context['full_build_path'], message)
+      end
+    end
+  end
+end

data/lib/docman/commands/ssh_target_checker.rb

@@ -0,0 +1,28 @@
+require 'net/sftp'
+
+module Docman
+
+  class SSHTargetChecker < Docman::TargetChecker
+    register_checker :ssh
+
+    def execute
+      filename = File.join(self['file_path'], @context['docroot_name'] + @context['environment'], self['filename'])
+      Net::SFTP.start(self['ssh_host'], self['ssh_user']) do |sftp|
+        n = 0
+        begin
+          n+=1
+          log "Checking if files deployed, retry ##{n}, filename: #{filename}"
+          sftp.stat!(filename) do |response|
+            unless response.ok?
+              sleep 15
+            end
+          end
+          data = YAML.load sftp.download!(filename)
+          sleep 30
+        end until data['random'] == self['version']
+      end
+      true
+    end
+
+  end
+end

data/lib/docman/commands/target_checker.rb

@@ -0,0 +1,22 @@
+require 'net/sftp'
+
+module Docman
+
+  class TargetChecker < Docman::Command
+    @@checkers = {}
+
+    def self.create(params = nil, context = nil)
+      c = @@checkers[params['handler']]
+      if c
+        c.new(params, context)
+      else
+        raise "Bad checker type: #{type}"
+      end
+    end
+
+    def self.register_checker(name)
+      @@checkers[name] = self
+    end
+
+  end
+end

data/lib/docman/config.rb

@@ -0,0 +1,31 @@
+require 'singleton'
+require 'hash_deep_merge'
+require 'digest/md5'
+
+module Docman
+  class Config < Hash
+
+    def initialize(file)
+      super
+      @config = YAML::load_file(file)
+      assign_to_self
+    end
+
+    def assign_to_self
+      @config.each_pair do |k, v|
+        self[k] = v
+      end
+    end
+
+    def merge_config_from_file(file)
+      config = YAML::load_file(file)
+      @config.deep_merge(config)
+      assign_to_self
+    end
+
+    def config_hash
+      Digest::MD5.hexdigest(Marshal::dump(self))
+    end
+
+  end
+end

data/lib/docman/context.rb

@@ -0,0 +1,11 @@
+require 'docman/logging'
+
+module Docman
+  module Context
+    include Docman::Logging
+
+    def describe(type = 'short')
+      self.class.name
+    end
+  end
+end

data/lib/docman/deployers/common_deployer.rb

@@ -4,8 +4,9 @@ module Docman
 
       register_deployer :common_deployer
 
-      def push(info, state_name)
+      def push
       end
+
     end
   end
 end

data/lib/docman/deployers/deployer.rb

@@ -1,38 +1,142 @@
+require 'docman/commands/target_checker'
+require 'docman/commands/ssh_target_checker'
+require 'docman/exceptions/no_changes_error'
+require 'securerandom'
+
 module Docman
   module Deployers
-    class Deployer
+    class Deployer < Docman::Command
+
+      attr_accessor :before, :after
 
-      attr_reader :deploy_target
+      define_hooks :before_push, :after_push
 
-      @@subclasses = {}
+      @@deployers = {}
 
-      def self.create(type, deploy_target)
-        c = @@subclasses[type]
+      def self.create(params, context = nil, caller = nil)
+        c = @@deployers[params['handler']]
         if c
-          c.new(deploy_target)
+          c.new(params, context, caller, 'deployer')
         else
           raise "Bad deployer type: #{type}"
         end
       end
 
       def self.register_deployer(name)
-        @@subclasses[name] = self
+        @@deployers[name] = self
+      end
+
+      def initialize(params, context = nil, caller = nil, type = nil)
+        super(params, context, caller, type)
+        @docroot_config = caller.docroot_config
+        @builded = []
+        @build_results = {}
+      end
+
+      def config
+        unless self['name'].nil?
+          @docroot_config.chain(@docroot_config.info_by(self['name'])).values.each do |info|
+            add_actions(info)
+          end
+        end
+      end
+
+      before_execute do
+        stored_config_hash = read_version_file_param('config_hash')
+        @config_hash = Docman::Application.instance.config.config_hash
+        stored_docroot_config_hash = read_version_file_param('docroot_config_hash')
+        @docroot_config_hash = @docroot_config.config_hash
+        # config = Docman::Application.instance.config
+        # log(config.to_yaml)
+        if stored_config_hash != @config_hash or stored_docroot_config_hash != @docroot_config_hash
+          logger.info 'Forced rebuild as configuration was changed'
+          Docman::Application.instance.force = true
+        end
+      end
+
+      def execute
+        logger.info "Deploy started"
+        if self['name'].nil?
+          build_recursive
+        else
+          build_dir_chain(@docroot_config.info_by(self['name']))
+        end
+
+        if @changed
+          filename = 'version.yaml'
+          path = File.join(@docroot_config.root['full_build_path'], filename)
+          version = SecureRandom.hex
+          write_version_file version, path
+          run_with_hooks('push')
+          raise 'Files are not deployed' unless files_deployed? version, filename
+        else
+          logger.info 'No changes in docroot'
+        end
+        logger.debug 'Deploy results:'
+        logger.debug @build_results.to_yaml
+        logger.info 'Deploy finished'
+      end
+
+      def read_version_file_param(param)
+        path = File.join(@docroot_config.root['full_build_path'], 'version.yaml')
+        return false unless File.file?(path)
+        content = YAML::load_file(path)
+        content[param] if content.has_key? param
       end
 
-      def initialize(deploy_target)
-        @deployed = []
-        @deploy_target = deploy_target
+      def write_version_file(version, path)
+        to_write = Hash.new
+        to_write['random'] = version
+        # config = Docman::Application.instance.config.raw_config
+        # log(config.to_yaml)
+        to_write['config_hash'] = @config_hash
+        to_write['docroot_config_hash'] = @docroot_config_hash
+        File.open(path, 'w') {|f| f.write to_write.to_yaml}
+      end
+
+      def build_dir_chain(info)
+        @docroot_config.chain(info).values.each do |item|
+          item.state = self['state']
+          if item.need_rebuild?
+            build_recursive(item)
+            return
+          elsif
+          build_dir(item)
+          end
+        end
+      end
+
+      def build_dir(info)
+        return if @builded.include? info['name']
+        info.state = self['state']
+
+        build_result = Docman::Builders::Builder.create(self['builders'][info['type']], info, self).perform
+        logger.info '-------------------------------------------------------'
+        @changed = true if build_result
+        @build_results[info['name']] = build_result
+
+        @builded << info['name']
+      end
+
+      def build_recursive(info = nil)
+        info = info ? info : @docroot_config.structure
+        build_dir(info)
+
+        info['children'].each do |child|
+          build_recursive(child)
+        end
       end
 
-      def build(root, info)
-        return if @deployed.include? info['name']
-        build_type = build_type(info['type'])
-        Docman::Builders::Builder.create(build_type['handler'], root, build_type, info).do()
-        @deployed << info['name']
+      def files_deployed?(version, filename)
+        return true unless self.has_key? 'target_checker'
+        params = self['target_checker']
+        params['version'] = version
+        params['filename'] = filename
+        Docman::TargetChecker.create(params, self).perform
       end
 
-      def build_type(type)
-        @deploy_target['builders'][type]
+      def describe(type = 'short')
+        properties_info(['handler'])
       end
 
     end