hookit 0.12.3 → 1.0.0

data/lib/hookit/resource/scp.rb

@@ -1,87 +0,0 @@
-module Hookit
-  module Resource
-    class Scp < Base
-
-      field :source
-      field :destination
-      field :port
-      field :recursive
-      field :config
-      field :cipher
-      field :identity
-      field :ssh_options
-      field :compression
-      field :preserve
-
-      actions :copy
-      default_action :copy
-
-      def initialize(name)
-        source(name) unless source
-        preserve(true) unless preserve
-        recursive(true) unless recursive
-        super
-      end
-
-      def run(action)
-        case action
-        when :copy
-          copy!
-        end
-      end
-
-      def copy!
-        run_command!("scp -q#{preserve!}#{recursive!}B#{compression!} #{config!} #{port!} #{cipher!} #{identity!} #{ssh_options!} #{source} #{destination}")
-      end
-
-      def cipher!
-        (return "-c #{cipher}") if cipher
-        ""
-      end
-
-      def compression!
-        (return "C") if compression
-        ""
-      end
-
-      def config!
-        (return "-F #{config}") if config
-        ""
-      end
-
-      def identity!
-        (return "-i #{identity}") if identity
-        ""
-      end
-
-      def port!
-        (return "-P #{port}") if port
-        ""
-      end
-
-      def preserve!
-        (return "p") if preserve
-        ""
-      end
-
-      def recursive!
-        (return "r") if recursive
-        ""
-      end
-
-      def ssh_options!
-        (return "-o #{ssh_options}") if ssh_options
-        ""
-      end
-
-      def run_command!(cmd, expect_code=0)
-        `#{cmd}`
-        code = $?.exitstatus
-        if code != expect_code
-          raise Hookit::Error::UnexpectedExit, "#{cmd} failed with exit code '#{code}'"
-        end
-      end
-
-    end
-  end
-end

data/lib/hookit/resource/service.rb

@@ -1,117 +0,0 @@
-module Hookit
-  module Resource
-    class Service < Base
-
-      field :recursive
-      field :service_name
-      field :init
-
-      actions :enable, :disable, :start, :stop, :restart, :reload
-      default_action :enable
-
-      def initialize(name)
-        service_name(name) unless service_name
-
-        # if init scheme is not provided, try to set reasonable defaults
-        if not init
-          case platform.name
-          when 'smartos'
-            init(:smf)
-          when 'ubuntu'
-            init(:upstart)
-          when 'docker'
-            init(:runit)
-          end
-        end
-      end
-
-      def run(action)
-        case action
-        when :enable
-          enable!
-        when :disable
-          disable!
-        when :start
-          enable!
-        when :stop
-          disable!
-        when :restart
-          restart!
-        when :reload
-          reload!
-        end
-      end
-
-      protected
-
-      def enable!
-        case init
-        when :smf
-          run_command! "svcadm enable -s #{"-r" if recursive} #{service_name}"
-        when :runit
-          # register and potentially start the service
-          run_command! "sv start #{service_name}", false
-
-          # runit can take up to 5 seconds to register the service before the
-          # service starts to run. We'll keep checking the status for up to 
-          # 6 seconds, after which time we'll raise an exception.
-          registered = false
-
-          6.times do
-            # check the status
-            `sv status #{service_name}`
-            if $?.exitstatus == 0
-              registered = true
-              break
-            end
-
-            sleep 1
-          end
-
-          if registered
-            # just in case the service is registered but not started, try
-            # to start the service one more time
-            run_command! "sv start #{service_name}"
-          else
-            raise Hookit::Error::UnexpectedExit "Service #{service_name} did not register within 6 seconds."
-          end
-
-        else
-          raise Hookit::Error::UnsupportedOption "Unsupported init schema '#{init}'"
-        end
-      end
-
-      def disable!
-        case init
-        when :smf
-          run_command! "svcadm disable -s #{service_name}"
-        when :runit
-          run_command! "sv stop #{service_name}"
-        else
-          raise Hookit::Error::UnsupportedOption "Unsupported init schema '#{init}'"
-        end
-      end
-
-      def restart!
-        case init
-        when :smf
-          run_command! "svcadm restart #{service_name}"
-        when :runit
-          disable!; enable!
-        else
-          raise Hookit::Error::UnsupportedOption "Unsupported init schema '#{init}'"
-        end
-      end
-
-      def reload!
-        case init
-        when :smf
-          run_command! "svcadm refresh #{service_name}"
-        else
-          raise Hookit::Error::UnsupportedOption "Unsupported init schema '#{init}'"
-        end
-      end
-
-    end
-  end
-end

data/lib/hookit/resource/socket.rb

@@ -1,78 +0,0 @@
-module Hookit
-  module Resource
-    class Socket < Base
-
-      field :port
-      field :interface
-      field :service
-      field :max_checks
-
-      actions :listening, :no_connections, :reset
-      default_action :listening
-
-      def initialize(name)
-        service name unless service
-        max_checks 3 unless max_checks
-        super
-
-        case platform.os
-        when 'sun'
-          @active_com   = "netstat -an | egrep '\*\.#{port}' | grep LISTEN"
-          @inactive_com = "netstat -an | grep 'ESTABLISHED' | awk '{ print $1 }' | grep \"$(ifconfig #{interface} | grep inet | awk '{ print $2 }')\.#{port}\""
-        else
-          @active_com   = "netstat -an | egrep ':#{port}' | grep LISTEN"
-          @inactive_com = "netstat -an | grep 'ESTABLISHED' | awk '{ print $4 }' | grep \"$(ifconfig #{interface} | awk '/inet addr/ { print $2}' | cut -f2 -d':' | tr -d '\n'):#{port}\""
-        end
-      end
-
-      def run(action)
-        case action
-        when :listening
-          check_listening!
-        when :no_connections
-          check_no_connections!
-        when :reset
-          reset!
-        end
-      end
-
-      protected
-
-      def check_listening!
-        # increment check
-        registry("#{service}.listening", registry("#{service}.listening").to_i + 1)
-
-        if `#{@active_com}`.empty?
-          count = registry("#{service}.listening").to_i
-          if count <= max_checks
-            sleep 1
-            exit(count + 10)
-          else
-            $stderr.puts "ERROR: timed out waiting for #{service} to listen"
-            exit(Hookit::Exit::ERROR)
-          end
-        end
-
-      end
-
-      def check_no_connections!
-        # increment check
-        registry("#{service}.no_connections", registry("#{service}.no_connections").to_i + 1)
-
-        unless `#{@inactive_com}`.empty?
-          count = registry("#{service}.no_connections").to_i
-          sleep 1
-          if count <= max_checks
-            exit(count + 10)
-          end
-        end
-      end
-
-      def reset!
-        registry("#{service}.listening", 0)
-        registry("#{service}.no_connections", 0)
-      end
-
-    end
-  end
-end

data/lib/hookit/resource/warning.rb

@@ -1,87 +0,0 @@
-module Hookit
-  module Resource
-    class Warning < Base
-
-      field :source
-      field :content
-      field :stream
-
-      actions :warn
-      default_action :warn
-
-      def initialize(name)
-        source(name) unless source or content
-        stream :stdout unless stream
-
-        @default_header = "\u25BC\u25BC\u25BC\u25BC :: WARNING :: \u25BC\u25BC\u25BC\u25BC"
-        @block_width = @default_header.length
-      end
-
-      def run(action)
-        case action
-        when :warn
-          warn!
-        end
-      end
-
-      protected
-
-      def gem
-        dict[:template_gem]
-      end
-
-      def gem_spec
-        Gem::Specification.find_by_name(gem)
-      end
-
-      def gem_root
-        gem_spec.gem_dir
-      end
-
-      def content!
-        output_string ||= content or ::File.open("#{gem_root}/messages/#{source}").read
-        return output_string
-      end
-
-      def header!
-
-        header = @default_header
-        padding = "\u25BC"
-
-        longest_line = content!.split.sort_by {|x| x.length}.last
-
-        if longest_line.length > header.length
-
-          difference = longest_line.length - header.length
-          padding *= (difference.to_f / 2).ceil
-
-          header = padding + header + padding
-        end
-
-        @block_width = header.length
-
-        puts header
-      end
-
-      def footer!
-        footer = "\u25B2" * @block_width
-        puts footer
-      end
-
-      def warn!
-
-        header!
-
-        case stream
-        when :stdout
-          puts content!
-        when :stderr
-          $stderr.puts content!
-        end
-
-        footer!
-      end
-
-    end
-  end
-end

data/lib/hookit/resource/zfs.rb

@@ -1,99 +0,0 @@
-module Hookit
-  module Resource
-    class Zfs < Base
-
-      field :snapshot
-      field :dataset
-      field :destination
-      field :source
-      field :ssh_host
-      field :validator
-      field :options
-
-      actions :send, :receive, :transmit, :snapshot, :destroy, :rollback, :clone
-      default_action :send
-
-      def initialize(name)
-        snapshot(name) unless snapshot
-        super
-      end
-
-      def run(action)
-        case action
-        when :send
-          send!
-        when :receive
-          receive!
-        when :transmit
-          transmit!
-        when :snapshot
-          snapshot!
-        when :destroy
-          destroy!
-        when :rollback
-          rollback!
-        when :clone
-          clone!
-        end
-      end
-
-      def send!
-        run_command! "zfs send #{snapshot} | #{destination}"
-      end
-
-      def receive!
-        run_command! "#{source.to_s.strip} | zfs receive -F #{dataset}"
-      end
-
-      def transmit!
-        if ssh_host
-          run_command! "zfs send #{options} #{snapshot} | ssh -o stricthostkeychecking=no #{ssh_host} zfs receive -F #{dataset}"
-        else
-          run_command! "zfs send #{options} #{snapshot} | zfs receive -F #{dataset}"
-        end
-      end
-
-      def snapshot!
-        destroy!
-        run_command! "zfs snapshot #{snapshot}"
-      end
-
-      def destroy!
-        `zfs list -t snapshot | grep #{snapshot}`
-        if $?.exitstatus == 0
-          run_command! "zfs destroy #{snapshot}"
-        end 
-      end
-
-      def rollback!
-        run_command! "zfs rollback -r #{snapshot}"
-      end
-
-      def clone!
-        run_command! "zfs clone #{snapshot} #{dataset}"
-      end
-
-      def validate!(res)
-        if validator.is_a? Proc
-          if validator.call(res)
-            res
-          else
-            raise "ERROR: execute resource \"#{name}\" failed validation!"
-          end
-        else
-          res
-        end
-      end
-
-      def run_command!(cmd, expect_code=0)
-        res = `#{cmd}`
-        code = $?.exitstatus
-        if code != expect_code
-          raise Hookit::Error::UnexpectedExit, "#{cmd} failed with exit code '#{code}'"
-        end
-        return validate!(res)
-      end
-
-    end
-  end
-end

data/lib/hookit/setup.rb

@@ -1,59 +0,0 @@
-# This file is meant ONLY as a way to make a hookit hook directly executable.
-#
-# Normally hookit is bootstrapped via `hookit hook-name "payload"`.
-#
-# This script allows a ruby executable script to bootstrap hookit and run as
-# a hook directly.
-#
-# Usage:
-#
-# #!/usr/bin/env ruby
-#
-# # optionally, set some configuration
-# # (if not set, MODULE_ROOT will default to the directory if this script)
-#
-# $LOG_LEVEL = :error
-# $LOGFILE = '/var/log/hookit/hookit.log'
-# $MODULE_DIR = "/opt/local/hookit/mod"
-#
-# # load hookit/setup to bootstrap hookit
-# require 'hookit/setup'
-#
-# execute 'list all the files!' do
-#   command 'ls -lah /'
-# end
-#
-
-# This won't handle every scenario, but essentially it tries to find the
-# location of the script that was executed
-hook = begin
-  if $0[0] == '/'
-    $0
-  else
-    "#{Dir.getwd}/#{$0}"
-  end
-end
-
-module_dir = File.dirname(hook)
-
-MODULE_DIR = $MODULE_DIR || ENV['MODULE_DIR'] || module_dir
-LOG_LEVEL  = $LOG_LEVEL || ENV['LOG_LEVEL'] || :error
-LOGFILE    = $LOGFILE || ENV['LOGFILE'] || '/var/log/hookit/hookit.log'
-
-require 'hookit'
-require 'json'
-
-include Hookit::Hook   # payload helpers / resource dsl
-
-set :log_level,   LOG_LEVEL
-set :logfile,     LOGFILE
-set :module_root, MODULE_DIR
-
-# require hook libs
-Dir.glob("#{MODULE_DIR}/lib/*.rb").each do |file|
-  require file
-end
-
-logger.info ""
-logger.info "hook: #{hook}"
-logger.info "payload: #{payload.to_json}"