angry_mob_common_targets 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010 PLUS2 Pty. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOa AND
+NONINFRINGEMENT. IN NO EVENT SaALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,38 @@
+# AngryMob Common Targets
+
+AngryMob Common Targets are a set of essential, reusable targets to get you started with AngryMob.
+
+## file targets
+
+### file
+
+### template
+
+### symlink
+
+### patch
+
+### tarball
+
+### fetch
+
+### git
+
+## package targets
+
+### apt
+
+### gem
+
+## os targets
+
+### service
+
+### sh
+
+### user
+
+### group
+
+### crontab
+

data/lib/common_mob.rb

@@ -0,0 +1,9 @@
+require 'pathname'
+root = Pathname('../../').expand_path(__FILE__)
+$LOAD_PATH << root+'vendor/mustache/lib'
+
+require 'common_mob/file'
+require 'common_mob/patch'
+require 'common_mob/digest'
+require 'common_mob/template'
+require 'common_mob/shell'

data/lib/common_mob/digest.rb

@@ -0,0 +1,43 @@
+require 'pathname'
+require 'digest/sha1'
+require 'digest/sha2'
+
+module CommonMob
+  module DigestHelper
+    def sha(string_or_io)
+      digest_with Digest::SHA1.new, string_or_io
+    end
+    def sha512(string_or_io)
+      digest_with Digest::SHA512.new, string_or_io
+    end
+    def sha256(string_or_io)
+      digest_with Digest::SHA256.new, string_or_io
+    end
+
+    def digest_with(digest,string_or_io)
+      if Pathname === string_or_io
+        if string_or_io.exist?
+          digest << string_or_io.read
+        else
+          return nil
+        end
+
+      elsif string_or_io.nil?
+        return nil
+      elsif string_or_io.respond_to?(:read)
+        digest << string_or_io.read
+      else
+        digest << string_or_io
+      end
+
+      digest.hexdigest
+    end
+
+    def generate_htpasswd(password)
+      pool = [ 'A'..'Z', 'a'..'z', '0'..'9' ].map {|r| r.to_a}.flatten
+      salt = [1,2].map {|_| pool[rand(pool.size)] }.join
+
+      password.to_s.crypt(salt)
+    end
+  end
+end

data/lib/common_mob/erb.rb

@@ -0,0 +1,72 @@
+require 'erb'
+
+module CommonMob
+  module Erb
+    class Context
+      def initialize(hash)
+        hash.each do |k,v|
+          instance_variable_set("@#{k}", convert_value(v))
+        end
+      end
+
+      def convert_value(value)
+        case value
+        when AngryHash
+          value
+        when Hash
+          AngryHash[value]
+        else
+          value
+        end
+      end
+
+      def get_binding
+        binding
+      end
+    end
+
+    class ErbError < StandardError
+      def initialize(file,ex)
+        @file = file
+        @src = file.read
+        @ex  = ex
+      end
+
+      def message
+        "error rendering erb: #{@ex.message}\nat line #{line_number+1} of #{@file}\n#{error_with_context * "\n"}"
+      end
+      def to_s
+        message
+      end
+
+      def error_with_context(ctx=2)
+        start_on_line = [ line_number - ctx - 1, 0          ].max
+        end_on_line   = [ line_number + ctx    , @src.length].min
+
+        @src.split("\n")[ start_on_line..end_on_line ]
+      end
+
+      def line_number
+        @line_number = line_number!
+      end
+      def line_number!
+        re = /\(erb\):(\d+):in `get_binding'/
+        @line_number = $1.to_i if @ex.backtrace.find {|line| line =~ re}
+      end
+
+      def method_missing(meth,*args,&block)
+        @ex.send(meth,*args,&block)
+      end
+    end
+
+    def render_erb(src,context)
+      e = ERB.new(src.read)
+      e.result( Context.new(context || {}).get_binding )
+    rescue Object
+      raise ErbError.new(src, $!)
+      #log "error rendering erb: [#{$!.class}] #{$!}"
+      #log e.src
+      #raise $!
+    end
+  end
+end

data/lib/common_mob/file.rb

@@ -0,0 +1,55 @@
+require 'pathname'
+require 'etc'
+
+module CommonMob
+  module FileHelper
+    def backup_file(f)
+      return if FalseClass === args.backup || args.backup == 0
+
+      backups = args.backups || 5
+      backups = backups.to_i
+
+      root = f.dirname
+      backedup = f.basename.to_s + ".AM-#{Time.now.to_i}"
+      backup = root+backedup
+
+      log "backing #{f} up to #{backup}"
+
+      FileUtils.cp f, (backup)
+
+      if backups > 0
+        existing_backups = Pathname.glob( root + "#{f.basename}.AM-*" ).sort_by {|f| f.ctime}.reverse
+        if existing_backups.size > backups
+          log "deleting #{existing_backups.size - backups} old backups (keeping #{backups})"
+          existing_backups[backups..-1].each {|to_del| to_del.unlink}
+        end
+      end
+
+      backup
+    rescue Errno::ENOENT
+      # *ulp*
+    end
+
+    def set_file_attrs(file,owner,group,mode)
+      file = Pathname(file)
+
+      unless owner.blank? && group.blank?
+        owner ||= file.stat.uid
+        group ||= file.stat.gid
+
+        owner = Etc.getpwnam(owner.to_s).uid unless Integer === owner
+        group = Etc.getgrnam(group.to_s).gid unless Integer === group
+
+        log "setting #{file} to owner=#{owner} group=#{group}"
+
+        file.chown(owner,group)
+      end
+
+      unless mode.blank?
+        log "setting #{file} to mode=0%o" % mode
+        file.chmod(mode) 
+      end
+    end
+    
+  end
+end

data/lib/common_mob/patch.rb

@@ -0,0 +1,51 @@
+module CommonMob
+  module PatchHelper
+    def patch_marker_re(comment,key,switch)
+      %[
+        #{Regexp.escape(comment.to_s)}
+        \\s+
+        angry-mob
+        \\s+
+        #{Regexp.escape(key.to_s)}
+        \\s+
+        #{Regexp.escape(switch.to_s)}
+        $
+      ]
+    end
+
+    def patch_string(to_patch, src, options={})
+      comment = options[:comment] || '#'
+      key     = options[:key]
+
+      content = "#{comment} angry-mob #{key} start\n#{src}" \
+        "\n#{comment} angry-mob #{key} end"
+
+      pattern = %r[
+        #{patch_marker_re(comment,key,'start')}
+        .*
+        #{patch_marker_re(comment,key,'end')}
+      ]mx
+
+      if to_patch[pattern]
+        to_patch.gsub(pattern,content)
+      else
+        to_patch + "\n" + content
+      end
+    end
+
+    def patch_file(to_patch)
+      log "what the very hell?"
+      if args.src?
+        src = args.src.pathname.read
+      elsif args.string?
+        src = args.string
+      end
+
+      patch_string(to_patch.read, src, {
+        :comment => args.comment,
+        :key => args.key,
+      })
+    end
+
+  end
+end

data/lib/common_mob/resource_locator.rb

@@ -0,0 +1,9 @@
+module CommonMob
+  class ResourceLocator
+    def resource(target,name)
+      path = target.act.definition_file.to_s.sub(/\.([^\.]+)$/,'')
+      (path.pathname + name.to_s)
+    end
+    alias_method :[], :resource
+  end
+end

data/lib/common_mob/shell.rb

@@ -0,0 +1,323 @@
+require 'fcntl'
+require 'stringio'
+
+module CommonMob
+  class ShellError < StandardError
+    attr_accessor :result
+  end
+
+  module ShellHelper
+    def sh(*args,&blk)
+      CommonMob::Shell.new(*args,&blk)
+    end
+
+    # call ruby, or a ruby command with the environment cleaned of bundler spooge
+    def bundler_sh(*args,&blk)
+      args.options.without_cleaning_bundler = true
+      CommonMob::Shell.new(*args,&blk)
+    end
+  end
+
+  class Shell
+    def debug(*msg)
+      AngryMob::Mob.ui.debug "sh: #{msg * ' '}"
+    end
+
+    attr_reader :options
+
+    def initialize(*args,&block)
+      @block = block
+      @options = if Hash === args.last then args.pop else {} end
+
+      unless args.empty?
+        @options[:cmd] = args
+      end
+
+      @options[:stream] = false unless @options.key?(:stream)
+    end
+
+    def execute
+      error,out = nil,nil
+
+      rv = popen4(options) {|pid,stdin,stdout,stderr|
+        out   = stdout.read
+        error = stderr.read
+      }
+      
+      # TODO print as debug
+
+      rv.stderr = error
+      rv.stdout = out
+
+      rv
+    end
+
+    def run
+      execute.ensure_ok!
+    end
+
+    def ok?
+      execute.ok?
+    end
+
+    def to_s
+      result = execute
+      if result.ok?
+        result.stdout.chomp
+      else
+        ''
+      end
+    end
+
+    class ShellResult < Struct.new(:process_result, :options, :stderr, :stdout)
+      def ok?
+        process_result.success?
+      end
+
+      def ensure_ok!
+        unless ok?
+          ex = ShellError.new("unable to run options=#{options.inspect}\noutput=#{stdout}\nerror=#{stderr}")
+          ex.result = self
+          raise(ex)
+        end
+      end
+    end
+
+    # This is taken directly from Chef and then modified to suit the needs of Igor.
+    #
+    # This is taken directly from Ara T Howard's Open4 library, and then 
+    # modified to suit the needs of Chef.  Any bugs here are most likely
+    # my own, and not Ara's.
+    #
+    # The original appears in external/open4.rb in its unmodified form. 
+    #
+    # Thanks Ara!
+    def popen4(args={}, &b)
+
+      cmd = args[:cmd]
+
+     
+      # Do we wait for the child process to die before we yield
+      # to the block, or after?
+      #
+      # By default, we are waiting before we yield the block.
+      args[:stream] ||= false
+      
+
+      args[:user] ||= nil
+      unless args[:user].kind_of?(Integer)
+        args[:user] = Etc.getpwnam(args[:user]).uid if args[:user]
+      end
+
+      args[:group] ||= nil
+      unless args[:group].kind_of?(Integer)
+        args[:group] = Etc.getgrnam(args[:group]).gid if args[:group]
+      end
+
+
+      args[:environment] ||= {}
+
+      # Default on C locale so parsing commands output can be done
+      # independently of the node's default locale.
+      # "LC_ALL" could be set to nil, in which case we also must ignore it.
+      unless args[:environment].has_key?("LC_ALL")
+        args[:environment]["LC_ALL"] = "C"
+      end
+
+      unless TrueClass === args[:without_cleaning_bundler]
+        args[:environment].update('RUBYOPT' => nil, 'BUNDLE_GEMFILE' => nil, 'GEM_HOME' => nil, 'GEM_PATH' => nil)
+      end
+
+      if user = args[:as]
+        if (evars = args[:environment].reject {|k,v| v.nil?}.map {|k,v| "#{k}=#{v}"}) && !evars.empty?
+          env = "env #{evars.join(' ')}"
+        else
+          env = ''
+        end
+        
+        cmd = "sudo -H -u #{user} #{env} #{cmd}"
+      end
+
+      # debug "running #{cmd} #{massaged_args(args).inspect}"
+      
+      pwrite, pread, perror, pexception = IO.pipe, IO.pipe, IO.pipe, IO.pipe
+
+      verbose = $VERBOSE
+      begin
+        $VERBOSE = nil
+        pexception.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+        cid = fork {
+          pwrite.last.close
+          STDIN.reopen pwrite.first
+          pwrite.first.close
+
+          pread.first.close
+          STDOUT.reopen pread.last
+          pread.last.close
+
+          perror.first.close
+          STDERR.reopen perror.last
+          perror.last.close
+
+          STDOUT.sync = STDERR.sync = true
+
+          if args[:group]
+            Process.egid = args[:group]
+            Process.gid = args[:group]
+          end
+
+          if args[:user]
+            Process.euid = args[:user]
+            Process.uid = args[:user]
+          end
+
+          # Copy the specified environment across to the child's environment.
+          # Keys with `nil` values are deleted from the environment.
+          args[:environment].each do |key,value|
+            if value.nil?
+              ENV.delete(key.to_s)
+            else
+              ENV[key.to_s] = value
+            end
+          end
+
+          if args[:umask]
+            umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777)
+            File.umask(umask)
+          end
+
+          if args[:cwd]
+            Dir.chdir args[:cwd]
+          end
+          
+          begin
+            if cmd.kind_of?(Array)
+              exec(*cmd)
+            else
+              exec(cmd)
+            end
+            raise 'forty-two' 
+          rescue Exception => e
+            Marshal.dump(e, pexception.last)
+            pexception.last.flush
+          end
+          pexception.last.close unless (pexception.last.closed?)
+          exit!
+        }
+      ensure
+        $VERBOSE = verbose
+      end
+
+      [pwrite.first, pread.last, perror.last, pexception.last].each{|fd| fd.close}
+
+      begin
+        e = Marshal.load pexception.first
+        raise(Exception === e ? e : "unknown failure!")
+      rescue EOFError # If we get an EOF error, then the exec was successful
+        42
+      ensure
+        pexception.first.close
+      end
+
+      pwrite.last.sync = true
+
+      pi = [pwrite.last, pread.first, perror.first]
+
+      if b 
+        begin
+          if args[:stream]
+            b[cid, *pi]
+            ShellResult.new(Process.waitpid2(cid).last, args)
+          else
+            o = StringIO.new
+            e = StringIO.new
+
+            if args[:input]
+              pi[0].puts args[:input]
+            end
+
+            pi[0].close
+            
+            stdout = pi[1]
+            stderr = pi[2]
+
+            stdout.sync = true
+            stderr.sync = true
+
+            stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+            stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+            
+            stdout_finished = false
+            stderr_finished = false
+           
+            results = nil
+
+            while !stdout_finished || !stderr_finished
+              begin
+                channels_to_watch = []
+                channels_to_watch << stdout if !stdout_finished
+                channels_to_watch << stderr if !stderr_finished
+                ready = IO.select(channels_to_watch, nil, nil, 1.0)
+              rescue Errno::EAGAIN
+                results = Process.waitpid2(cid, Process::WNOHANG)
+                if results
+                  stdout_finished = true
+                  stderr_finished = true 
+                end
+              end
+
+              if ready && ready.first.include?(stdout)
+                line = results ? stdout.gets(nil) : stdout.gets
+                if line
+                  o.write(line)
+                else
+                  stdout_finished = true
+                end
+              end
+              if ready && ready.first.include?(stderr)
+                line = results ? stderr.gets(nil) : stderr.gets
+                if line
+                  e.write(line)
+                else
+                  stderr_finished = true
+                end
+              end
+            end
+            results = Process.waitpid2(cid).last unless results
+            o.rewind
+            e.rewind
+            b[cid, pi[0], o, e]
+
+            ShellResult.new(results, args)
+          end
+        ensure
+          pi.each{|fd| fd.close unless fd.closed?}
+        end
+      else
+        [cid, pw.last, pr.first, pe.first]
+      end
+    end
+
+    def massaged_args args
+      returning(args.dup) do |args_to_print|
+        args_to_print[:environment] = e = args[:environment].dup
+
+        %w{LC_ALL GEM_HOME GEM_PATH RUBYOPT BUNDLE_GEMFILE}.each {|env| e.delete(env)}
+
+        args_to_print['cwd'] = args_to_print['cwd'].to_s if args_to_print['cwd']
+
+        args_to_print.delete_if{|k,v| v.blank?}
+      end
+    end
+
+  end
+end
+
+class String
+  def sh(options={})
+    CommonMob::Shell.new(self,options)
+  end
+end
+
+