micro-hookit 0.12.11

data/lib/hookit/resource/scp.rb

@@ -0,0 +1,78 @@
+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
+    end
+  end
+end

data/lib/hookit/resource/service.rb

@@ -0,0 +1,117 @@
+module Hookit
+  module Resource
+    class Service < Base
+
+      field :recursive
+      field :service_name
+      field :init
+      field :timeout
+
+      actions :enable, :disable, :start, :stop, :force_stop, :restart, :reload
+      default_action :enable
+
+      def initialize(name)
+        service_name(name) unless service_name
+        super
+
+        # 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 :force_stop
+          force_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 #{"-w #{timeout}" if timeout} 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 #{"-w #{timeout}" if timeout} start #{service_name}"
+          end
+        end
+      end
+
+      def disable!
+        case init
+        when :smf
+          run_command! "svcadm disable -s #{service_name}"
+        when :runit
+          run_command! "sv #{"-w #{timeout}" if timeout} stop #{service_name}"
+        end
+      end
+
+      def force_disable!
+        case init
+        when :runit
+          run_command! "sv #{"-w #{timeout}" if timeout} force-stop #{service_name}"
+        end
+      end
+
+      def restart!
+        case init
+        when :smf
+          run_command! "svcadm restart #{service_name}"
+        when :runit
+          disable!; enable!
+        end
+      end
+
+      def reload!
+        case init
+        when :smf
+          run_command! "svcadm refresh #{service_name}"
+        end
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/socket.rb

@@ -0,0 +1,79 @@
+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
+            print_error(name, {
+              reason: "timed out waiting for #{service} to listen"
+            })
+          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/template.rb

@@ -0,0 +1,114 @@
+require 'tilt'
+require 'erubis'
+require 'erb'
+require 'oj'
+require 'multi_json'
+
+module Hookit
+  module Resource
+    class Template < Base
+      
+      field :path
+      field :source
+      field :variables
+      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)}.erb"
+        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
+          Tilt.new("#{template_dir}/#{source}").render(self, variables)
+        rescue Exception => e
+          unexpected_failure("render template", e.message)
+        end
+      end
+
+      def template_dir
+        "#{module_root}/templates"
+      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/warning.rb

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,77 @@
+module Hookit
+  module Resource
+    class Zfs < Base
+
+      field :snapshot
+      field :dataset
+      field :destination
+      field :source
+      field :ssh_host
+      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
+
+    end
+  end
+end

data/lib/hookit/resource.rb

@@ -0,0 +1,21 @@
+require 'hookit/resource/base'
+require 'hookit/resource/directory'
+require 'hookit/resource/execute'
+require 'hookit/resource/file'
+require 'hookit/resource/hook_file'
+require 'hookit/resource/link'
+require 'hookit/resource/logrotate'
+require 'hookit/resource/mount'
+require 'hookit/resource/package'
+require 'hookit/resource/rsync'
+require 'hookit/resource/socket'
+require 'hookit/resource/scp'
+require 'hookit/resource/service'
+require 'hookit/resource/template'
+require 'hookit/resource/zfs'
+
+module Hookit
+  module Resource
+    
+  end
+end

data/lib/hookit/resources.rb

@@ -0,0 +1,15 @@
+Hookit.resources.register(:directory)      { Hookit::Resource::Directory }
+Hookit.resources.register(:ensure_socket)  { Hookit::Resource::Socket }
+Hookit.resources.register(:execute)        { Hookit::Resource::Execute }
+Hookit.resources.register(:file)           { Hookit::Resource::File }
+Hookit.resources.register(:hook_file)      { Hookit::Resource::HookFile }
+Hookit.resources.register(:hookit_file)    { Hookit::Resource::HookFile }
+Hookit.resources.register(:link)           { Hookit::Resource::Link }
+Hookit.resources.register(:logrotate)      { Hookit::Resource::Logrotate }
+Hookit.resources.register(:mount)          { Hookit::Resource::Mount }
+Hookit.resources.register(:package)        { Hookit::Resource::Package }
+Hookit.resources.register(:rsync)          { Hookit::Resource::Rsync }
+Hookit.resources.register(:scp)            { Hookit::Resource::Scp }
+Hookit.resources.register(:service)        { Hookit::Resource::Service }
+Hookit.resources.register(:template)       { Hookit::Resource::Template }
+Hookit.resources.register(:zfs)            { Hookit::Resource::Zfs }

data/lib/hookit/setup.rb

@@ -0,0 +1,59 @@
+# 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}"

data/lib/hookit/version.rb

@@ -0,0 +1,3 @@
+module Hookit
+  VERSION = "0.12.11"
+end

data/lib/hookit.rb

@@ -0,0 +1,26 @@
+require 'hookit/converginator'
+require 'hookit/db'
+require 'hookit/error'
+require 'hookit/exit'
+require 'hookit/helper'
+require 'hookit/hook'
+require 'hookit/logger'
+require 'hookit/platform'
+require 'hookit/registry'
+require 'hookit/resource'
+require "hookit/version"
+
+module Hookit
+  extend self
+
+  def resources
+    @resources ||= Hookit::Registry.new
+  end
+
+  def platforms
+    @platforms ||= Hookit::Registry.new
+  end
+end
+
+require 'hookit/resources'
+require 'hookit/platforms'