micro-hookit 0.12.11

data/lib/hookit/resource/execute.rb

@@ -0,0 +1,205 @@
+require 'timeout'
+require 'open3'
+
+module Hookit
+  module Resource
+    class Execute < Base
+
+      field :command
+      field :cwd
+      field :environment
+      field :user
+      field :path
+      field :returns
+      field :timeout
+      field :stream
+      field :on_data
+      field :on_stdout
+      field :on_stderr
+      field :on_exit
+      field :validator
+      field :ignore_exit
+
+      actions :run
+      default_action :run
+
+      def initialize(name)
+        command name unless command
+        returns 0
+        super
+      end
+
+      def run(action)
+        case action
+        when :run
+          if stream
+            stream!
+          else
+            run!
+          end
+        end
+      end
+
+      protected
+
+      def validate!(res)
+        if validator.is_a? Proc
+          if validator.call(res)
+            res
+          else
+            print_error(name, {
+              command: cmd,
+              failure: "failed validation"
+            })
+          end
+        else
+          res
+        end
+      end
+
+      def run!
+        timeout = timeout || 3600
+        stream!
+      end
+
+      def stream!
+        exit_status = 0
+        result = ""
+
+        # don't buffer /stdin/stdout/stderr
+        STDIN.sync  = true
+        STDOUT.sync = true
+        STDERR.sync = true 
+        
+        Open3.popen3 cmd do |stdin, stdout, stderr, wait_thr|
+          begin
+            Timeout::timeout(timeout) do
+              stdout_eof = false
+              stderr_eof = false
+
+              until stdout_eof and stderr_eof do
+                (ready_pipes, dummy, dummy) = IO.select([STDIN, stdout, stderr])
+                ready_pipes.each_with_index do |socket|
+                  if socket == stdout
+                    begin
+                      chunk = socket.readpartial(4096)
+                      if on_data and on_data.respond_to? :call
+                        on_data.call(chunk)
+                      end
+                      if on_stdout and on_stdout.respond_to? :call
+                        on_stdout.call(chunk)
+                      end
+                    rescue EOFError
+                      stdout_eof = true
+                    end
+                    result << chunk.to_s
+                  elsif socket == stderr
+                    begin
+                      chunk = socket.readpartial(4096)
+                      if on_data and on_data.respond_to? :call
+                        on_data.call(chunk)
+                      end
+                      if on_stderr and on_stderr.respond_to? :call
+                        on_stderr.call(chunk)
+                      end
+                    rescue EOFError
+                      stderr_eof = true
+                    end
+                    result << chunk.to_s
+                  elsif socket == STDIN
+                    # write what we got on STDIN right into the process' stdin
+                    chunk = socket.readpartial(4096)
+                    stdin.write(chunk)
+                  end
+                end
+              end
+            end
+          rescue Timeout::Error => e
+            Process.kill 9, wait_thr[:pid]
+
+            print_error(name, {
+              command: cmd,
+              failure: "failed to return within #{timeout} seconds"
+            })
+            exit 1
+          end
+
+
+          exit_status = wait_thr.value.to_s.match(/exit (\d+)/)[1].to_i
+        end
+
+        if on_exit and on_exit.respond_to? :call
+          on_exit.call(exit_status)
+        else
+          unexpected_exit(exit_status, result) unless exit_status == returns
+        end
+
+        validate! result
+      end
+
+      def cmd
+        com = command
+
+        if environment
+          com = "#{env}#{com}"
+        end
+
+        if path
+          com = "export PATH=\"#{path}\"; #{com}"
+        end
+
+        if cwd
+          com = "cd #{cwd}; #{com}"
+        end
+
+        if user
+          com = su(user, com)
+        end
+
+       com
+      end
+
+      # strategy:
+      # 1- escape the escapes
+      # 2- escape quotes
+      # 3- escape dollar signs
+      def escape(cmd)
+        cmd.gsub!(/\\/, "\\\\\\")
+        cmd.gsub!(/"/, "\\\"")
+        cmd.gsub!(/\$/, "\\$")
+        cmd
+      end
+
+      def su(user, cmd)
+        "su - #{user} -c \"#{escape(cmd)}\""
+      end
+
+      def env
+        vars = environment || {}
+        env = ''
+        vars.each do |key, val|
+          env += " " if not env == ''
+          env += env_string(key, val)
+        end
+        (env == '')? env : "#{env} "
+      end
+
+      def env_string(key, val)
+        key = key.to_s if not key.is_a? String
+        val = val.to_s if not val.is_a? String
+        %Q{export #{key.upcase}="#{escape(val)}";}
+      end
+      
+      def unexpected_exit(res, output="")
+        return if ignore_exit
+        
+        print_error(name, {
+          exit: "#{res}",
+          command: cmd,
+          output: output
+        })
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/file.rb

@@ -0,0 +1,89 @@
+module Hookit
+  module Resource
+    class File < Base
+
+      field :path
+      field :content
+      field :mode
+      field :owner
+      field :group
+
+      actions :create, :create_if_missing, :delete, :touch
+      default_action :create
+
+      def initialize(name)
+        path name unless path
+        super
+      end
+
+      def run(action)
+        case action
+        when :create
+          create!
+          chown!
+          chmod!            
+        when :create_if_missing
+          create_if_missing!
+          chown!
+          chmod!
+        when :delete
+          delete!
+        when :touch
+          touch!
+        end
+      end
+
+      protected
+
+      def create!
+        begin
+          ::File.write path, (content || "")
+        rescue Exception => e
+          unexpected_failure("create file", e.message)
+        end
+      end
+
+      def create_if_missing!
+        if not ::File.exists? path
+          create!
+        end
+      end
+
+      def delete!
+        begin
+          ::File.delete path
+        rescue Exception => e
+          unexpected_failure("delete file", e.message)
+        end
+      end
+
+      def chown!
+        return unless owner or group
+        if ::File.exists? path
+          run_command! "chown #{(group.nil?) ? owner : "#{owner}:#{group}"} #{path}"
+        end
+      end
+
+      def chmod!
+        if ::File.exists? path and mode
+          begin
+            ::File.chmod(mode, path)
+          rescue Exception => e
+            unexpected_failure("chmod file", e.message)
+          end
+        end
+      end
+
+      def touch!
+        run_command! "touch -c #{path}"
+      end
+
+      def unexpected_failure(message, reason)
+        print_error(message, {
+          path: path,
+          reason: reason
+        })
+      end
+    end
+  end
+end

data/lib/hookit/resource/hook_file.rb

@@ -0,0 +1,109 @@
+module Hookit
+  module Resource
+    class HookFile < Base
+      
+      field :path
+      field :source
+      field :mode
+      field :owner
+      field :group
+
+      actions :create, :create_if_missing, :delete, :touch
+      default_action :create
+
+      def initialize(name)
+        path name unless path
+        source ::File.basename(name)
+        super
+      end
+
+      def run(action)
+        case action
+        when :create
+          create!
+          chown!
+          chmod!            
+        when :create_if_missing
+          create_if_missing!
+          chown!
+          chmod!
+        when :delete
+          delete!
+        when :touch
+          touch!
+        end
+      end
+
+      protected
+
+      def create!
+        begin
+          ::File.write path, render
+        rescue Exception => e
+          unexpected_failure("create file", e.message)
+        end
+      end
+
+      def create_if_missing!
+        if not ::File.exists? path
+          create!
+        end
+      end
+
+      def delete!
+        begin
+          ::File.delete path
+        rescue Exception => e
+          unexpected_failure("delete file", e.message)
+        end
+      end
+
+      def chown!
+        return unless owner or group
+        if ::File.exists? path
+          run_command! "chown #{(group.nil?) ? owner : "#{owner}:#{group}"} #{path}"
+        end
+      end
+
+      def chmod!
+        if ::File.exists? path and mode
+          begin
+            ::File.chmod(mode, path)
+          rescue Exception => e
+            unexpected_failure("chmod file", e.message)
+          end
+        end
+      end
+
+      def touch!
+        run_command! "touch -c #{path}"
+      end
+
+      def render
+        begin
+          ::File.read("#{file_dir}/#{source}")
+        rescue Exception => e
+          print_error("read hook_file", {
+            path: "#{file_dir}/#{source}",
+            reason: e.message
+          })
+        end
+      end
+
+      def file_dir
+        "#{module_root}/files"
+      end
+
+      def module_root
+        dict[:module_root]
+      end
+
+      def unexpected_failure(message, reason)
+        print_error(message, {
+          path: path,
+          reason: reason
+        })
+      end
+    end
+  end
+end

data/lib/hookit/resource/link.rb

@@ -0,0 +1,50 @@
+module Hookit
+  module Resource
+    class Link < Base
+
+      field :owner
+      field :group
+      field :link_type
+      field :target_file
+      field :to
+
+      actions :create, :delete
+      default_action :create
+
+      def initialize(name)
+        target_file name unless target_file
+        link_type :symbolic
+        super
+      end
+
+      def run(action)
+        case action
+        when :create
+          create!
+          chown!
+        when :delete
+          delete!
+        end
+      end
+
+      protected
+
+      def create!
+        args = ['f']
+        args << 'sn' if link_type == :symbolic
+        run_command! "ln -#{args.join} #{to} #{target_file}"
+      end
+
+      def delete!
+        run_command! "rm -f #{target_file}"
+      end
+
+      def chown!
+        return unless owner or group
+        if ::File.exists? target_file
+          run_command! "chown #{(group.nil?) ? owner : "#{owner}:#{group}"} #{target_file}"
+        end
+      end
+    end
+  end
+end

data/lib/hookit/resource/logrotate.rb

@@ -0,0 +1,36 @@
+module Hookit
+  module Resource
+    class Logrotate < Base
+
+      field :path
+      field :filesize
+      field :max_size
+      field :count
+
+      actions :create
+      default_action :create
+
+      def initialize(name)
+        path name unless path
+        super
+      end
+
+      def run(action)
+        case action
+        when :create
+          create!
+        end
+      end
+
+      protected
+
+      def create!
+        case platform.os
+        when 'sun'
+          run_command! `logadm -c -w #{path} -s #{filesize ||= '10m'} -S #{max_size ||= '500m'} -C #{count ||= '10'} -N`
+        end
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/mount.rb

@@ -0,0 +1,85 @@
+module Hookit
+  module Resource
+    class Mount < Base
+
+      field :device
+      # field :device_type
+      # field :dump
+      field :fstype
+      field :mount_point
+      field :options
+      field :pass
+      field :supports
+
+      actions :mount, :umount, :remount, :enable, :disable
+      default_action :mount
+
+      def initialize(name)
+        mount_point(name) unless mount_point
+        pass('-') unless pass
+        super
+      end
+
+      def run(action)
+        case action
+        when :mount
+          mount!
+        when :umount
+          umount!
+        when :remount
+          umount!
+          mount!
+        when :enable
+          disable!
+          enable!
+        when :disable
+          disable!
+        end
+      end
+
+      protected
+
+      def mount!
+        ::FileUtils.mkdir_p(mount_point)
+        case platform.os
+        when 'sun'
+          run_command! "mount -O -F #{fstype} -o retry=5,timeo=300 #{options!(as_arg=true)} #{device} #{mount_point}"
+        when 'linux'
+          run_command! "mount -t #{fstype} -o retry=5,timeo=300 #{options!(as_arg=true)} #{device} #{mount_point}"
+        end
+      end
+
+      def umount!
+        run_command! "umount #{mount_point}"
+      end
+
+      def enable!
+        entry = "#{device}\t#{device =~ /^\/dev/ ? device : "-"}\t#{mount_point}\t#{fstype}\t#{pass}\tyes\t#{options!}"
+        case platform.os
+        when 'sun'
+          run_command! `echo "#{entry}" >> /etc/vfstab`
+        when 'linux'
+          run_command! `echo "#{entry}" >> /etc/fstab`
+        end
+      end
+
+      def disable!
+        case platform.os
+        when 'sun'
+          run_command! `egrep -v "#{device}.*#{mount_point}" /etc/vfstab > /tmp/vfstab.tmp; mv -f /tmp/vfstab.tmp /etc/vfstab`
+        when 'linux'
+          run_command! `egrep -v "#{device}.*#{mount_point}" /etc/fstab > /tmp/vfstab.tmp; mv -f /tmp/vfstab.tmp /etc/vfstab`
+        end
+      end
+
+      def options!(as_arg=false)
+        options = self.options.kind_of?(Array) ? self.options.join(',') : self.options
+        if as_arg
+          options ? (return "-o #{options}") : (return "")
+        end
+        options != "" ? (return "#{options}") : (return "-")
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/package.rb

@@ -0,0 +1,57 @@
+module Hookit
+  module Resource
+    class Package < Base
+
+      field :package_name
+      field :source
+      field :version
+      field :scope
+
+      actions :install, :update
+      default_action :install
+
+      def initialize(name)
+        package_name(name) unless source
+        scope :default unless scope
+        super
+      end
+
+      def run(action)
+        case action
+        when :install
+          install!
+        when :update
+          update!
+        end
+      end
+
+      def install!
+        run_command! "#{pkgin} -y in #{package}"
+      end
+      
+      def update!
+        run_command! `#{pkgin} -y up`
+      end
+
+      protected
+
+      def package
+        if version
+          "#{package_name}-#{version}"
+        else
+          package_name
+        end
+      end
+
+      def pkgin
+        case scope
+        when :default
+          "/opt/local/bin/pkgin"
+        when :gomicro
+          "/opt/gomicro/bin/pkgin"
+        end
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/rsync.rb

@@ -0,0 +1,58 @@
+module Hookit
+  module Resource
+    class Rsync < Base
+
+      field :source
+      field :destination
+      field :wrapper
+      field :archive
+      field :recursive
+      field :checksum
+      field :compress
+
+      actions :sync
+      default_action :sync
+
+      def initialize(name)
+        source name unless source
+        super
+      end
+
+      def run(action)
+        case action
+        when :sync
+          sync!
+        end
+      end
+
+      def sync!
+        run_command! "rsync -q#{archive!}#{recursive!}#{checksum!}#{compress!} #{wrapper!} #{source} #{destination}"
+      end
+
+      def archive!
+        (return "a") if archive
+        ""
+      end
+
+      def recursive!
+        (return "r") if archive
+        ""
+      end
+
+      def checksum!
+        (return "c") if archive
+        ""
+      end
+
+      def compress!
+        (return "z") if archive
+        ""
+      end
+
+      def wrapper!
+        (return "-e '#{wrapper}'") if wrapper
+        ""
+      end
+    end
+  end
+end