micro-hookit 0.12.11

data/lib/hookit/hook.rb

@@ -0,0 +1,96 @@
+require 'oj'
+require 'multi_json'
+
+module Hookit
+  module Hook
+
+    def payload
+      @payload ||= parse_payload
+    end
+
+    def parse_payload
+      if not ARGV.empty?
+        MultiJson.load ARGV.first, symbolize_keys: true
+      else
+        {}
+      end
+    end
+
+    def converge(map, list)
+      Converginator.new(map, list).converge!
+    end
+
+    def registry(key, value=nil)
+      # normalize the catalog with keys
+      key = key.to_sym
+      unless value.nil?
+        db.put(key, value)
+      else
+        db.fetch(key)
+      end
+    end
+
+    def db
+      @db ||= Hookit::DB.new
+    end
+
+    def dict
+      @dict ||= {}
+    end
+
+    def set(key, value)
+      dict[key] = value
+    end
+
+    def get(key)
+      dict[key]
+    end
+
+    def log(level, message)
+      logger.log level, message
+    end
+
+    def logger
+      @logger ||= Hookit::Logger.new(get(:logfile), get(:log_level))
+    end
+
+    def platform
+      @platform ||= detect_platform
+    end
+
+    def detect_platform
+      Hookit.platforms.each do |key, value|
+        platform = value.new
+        if platform.detect?
+          return platform
+        end
+      end
+      false
+    end
+
+    # awesome resource-backed dsl
+    def method_missing(method_symbol, *args, &block)
+      resource_klass = Hookit.resources.get(method_symbol)
+      if resource_klass
+        resource = resource_klass.new(*args)
+        resource.dict = dict
+        resource.instance_eval(&block) if block_given?
+        if resource.can_run?
+          actions = resource.action
+          if actions.length > 1
+            res = {}
+            actions.each do |action|
+              res[action] = resource.run action
+            end
+            res
+          else
+            resource.run actions.first
+          end
+        end
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/hookit/logger.rb

@@ -0,0 +1,60 @@
+module Hookit
+  class Logger
+    require 'fileutils'
+    
+    attr_reader :log_file, :log_level
+
+    def initialize(file, level)
+      @log_file  = file   || '/var/log/hookit/hookit.log'
+      @log_level = level  || :error
+      ::FileUtils.mkdir_p(File.dirname(@log_file))
+    end
+
+    def log(level, message)
+
+      if not message
+        message = level
+        level   = :error
+      end
+
+      if level_to_int(level) <= level_to_int(log_level)
+        send(level, message)
+      end
+
+    end
+
+    def error(message)
+      log! "[error]: #{message}\n"
+    end
+
+    def warn(message)
+      log! "[warn]: #{message}\n"
+    end
+
+    def info(message)
+      log! "[info]: #{message}\n"
+    end
+
+    def debug(message)
+      log! "[debug]: #{message}\n"
+    end
+
+    protected
+
+    def log!(message)
+      File.open log_file, 'a'  do |f| 
+        f.write message
+      end
+    end
+
+    def level_to_int(level)
+      case level
+      when :error then 1
+      when :warn  then 2
+      when :info  then 3
+      when :debug then 4
+      end
+    end
+
+  end
+end

data/lib/hookit/platform/base.rb

@@ -0,0 +1,11 @@
+module Hookit
+  module Platform
+    class Base
+
+      def detect?; end
+      def name; end
+      def os; end
+
+    end    
+  end
+end

data/lib/hookit/platform/docker.rb

@@ -0,0 +1,22 @@
+module Hookit
+  module Platform
+    class Docker < Base
+      
+      def detect?
+        ! `if [ -f "/.dockerenv" ] || [ -f "/.dockerinit" ] || \
+          grep -qF /docker/ "/proc/self/cgroup" 2>/dev/null; then
+            echo docker
+        fi`.empty?
+      end
+
+      def name
+        'docker'
+      end
+
+      def os
+        'linux'
+      end
+
+    end
+  end
+end

data/lib/hookit/platform/smartos.rb

@@ -0,0 +1,19 @@
+module Hookit
+  module Platform
+    class Smartos < Base
+      
+      def detect?
+        ! `cat /etc/release 2>/dev/null | grep -i SmartOS`.empty? 
+      end
+
+      def name
+        'smartos'
+      end
+
+      def os
+        'sun'
+      end
+
+    end
+  end
+end

data/lib/hookit/platform/ubuntu.rb

@@ -0,0 +1,19 @@
+module Hookit
+  module Platform
+    class Ubuntu < Base
+      
+      def detect?
+        ! `[ -x /usr/bin/lsb_release ] && /usr/bin/lsb_release -i 2>/dev/null | grep Ubuntu`.empty?
+      end
+
+      def name
+        'ubuntu'
+      end
+
+      def os
+        'linux'
+      end
+      
+    end
+  end
+end

data/lib/hookit/platform.rb

@@ -0,0 +1,10 @@
+require 'hookit/platform/base'
+require 'hookit/platform/docker'
+require 'hookit/platform/smartos'
+require 'hookit/platform/ubuntu'
+
+module Hookit
+  module Platform
+    
+  end
+end

data/lib/hookit/platforms.rb

@@ -0,0 +1,3 @@
+Hookit.platforms.register(:docker)   { Hookit::Platform::Docker }
+Hookit.platforms.register(:smartos)  { Hookit::Platform::Smartos }
+Hookit.platforms.register(:ubuntu)   { Hookit::Platform::Ubuntu }

data/lib/hookit/registry.rb

@@ -0,0 +1,53 @@
+module Hookit
+  # Register components in a single location that can be queried.
+  #
+  # This allows certain components (such as guest systems, configuration
+  # pieces, etc.) to be registered and queried.
+  class Registry
+    def initialize
+      @actions = {}
+      @results_cache = {}
+    end
+
+    # Register a callable by key.
+    #
+    # The callable should be given in a block which will be lazily evaluated
+    # when the action is needed.
+    #
+    # If an action by the given name already exists then it will be
+    # overwritten.
+    def register(key, value=nil, &block)
+      @results_cache.delete key
+      block = lambda { value } unless value.nil?
+      @actions[key] = block
+    end
+
+    # Get an action by the given key.
+    #
+    # This will evaluate the block given to `register` and return the resulting
+    # action stack.
+    def get(key)
+      return nil unless @actions.has_key?(key)
+      return @results_cache[key] if @results_cache.has_key?(key)
+      @results_cache[key] = @actions[key].call
+    end
+    alias :[] :get
+
+    # Iterate over the keyspace.
+    def each(&block)
+      @actions.each do |key, _|
+        yield key, get(key)
+      end
+    end
+
+    # Converts this registry to a hash
+    def to_hash
+      result = {}
+      self.each do |key, value|
+        result[key] = value
+      end
+
+      result
+    end
+  end
+end

data/lib/hookit/resource/base.rb

@@ -0,0 +1,138 @@
+module Hookit
+  module Resource
+    class Base
+
+      class << self
+
+        def field(key)
+          define_method key do |*args, &block|
+            if data = block || args[0]
+              instance_variable_set("@#{key}", data)
+            else
+              instance_variable_get("@#{key}")
+            end
+          end
+        end
+
+        def actions(*actions)
+          if actions.any?
+            @actions = *actions
+          else
+            @actions    
+          end
+        end
+
+        def default_action(action=nil)
+          if action
+            @default_action = action
+          else
+            @default_action || :run
+          end
+        end
+        
+      end
+
+      attr_accessor :dict
+
+      field :name
+
+      def initialize(name)
+        name(name)
+      end
+
+      def run(action); end
+
+      def can_run?
+        only_if_res = true
+        not_if_res  = false
+
+        if only_if and only_if.respond_to? :call
+          only_if_res = only_if.call
+        end
+
+        if not_if and not_if.respond_to? :call
+          not_if_res = not_if.call
+        end
+
+        only_if_res and not not_if_res
+      end
+
+      def action(*actions)
+        if actions.any?
+          actions.each do |action|
+            if not self.class.actions.include? action
+              raise Hookit::Error::UnknownAction, "unknown action '#{action}'"
+            end
+          end
+          @actions = *actions
+        else
+          @actions || [default_action]
+        end
+      end
+
+      def default_action
+        self.class.default_action
+      end
+
+      def not_if(&block)
+        if block_given?
+          @not_if = block  
+        else
+          @not_if
+        end
+      end
+
+      def only_if(&block)
+        if block_given?
+          @only_if = block  
+        else
+          @only_if
+        end
+      end
+
+      protected
+
+      def run_command!(cmd, expect_code=0)
+        res = `#{cmd} 2>&1`
+        code = $?.exitstatus
+
+        # break early if the caller doesn't want to validate the exit code
+        if expect_code == false
+          return
+        end
+
+        if code != expect_code
+          print_error(name, {
+            exit: "#{code}",
+            command: cmd,
+            output: res
+          })
+        end
+      end
+      
+      # print_error prints an error message to the user explaining
+      # what happened. This is intended to be a pleasant alternative
+      # to a ruby stack trace.
+      def print_error(message, opts={})
+        STDERR.puts
+        STDERR.puts "! FAILED TO #{message.upcase} !"
+        STDERR.puts
+        
+        opts.each_pair do |k, v|
+          next if v.nil? || v == ""
+          
+          STDERR.puts "#{k.capitalize}"
+          
+          v.split("\n").each do |line|
+            STDERR.puts " #{line}"
+          end
+          
+          STDERR.puts
+        end
+        
+        exit 1
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/cron.rb

@@ -0,0 +1,29 @@
+module Hookit
+  module Resource
+    class Cron < Execute
+
+      def initialize(name)
+        super
+        timeout 60
+        cwd '/data'
+      end
+
+      protected
+
+      def run!
+        begin
+          Timeout::timeout(timeout) do
+            f = IO.popen("#{cmd} || exit 0", :err=>[:child, :out])
+            puts f.readline while true
+          end
+        rescue Timeout::Error
+          print_error(name, {
+            command: cmd,
+            failure: "failed to return within #{timeout} seconds"
+          })
+        end
+      end
+      
+    end
+  end
+end

data/lib/hookit/resource/directory.rb

@@ -0,0 +1,69 @@
+module Hookit
+  module Resource
+    class Directory < Base
+
+      field :path
+      field :recursive
+      field :mode
+      field :owner
+      field :group
+      
+      actions :create, :delete
+      default_action :create
+
+      def initialize(name)
+        path name unless path
+        super
+      end
+
+      def run(action)
+        case action
+        when :create
+          create!
+          chown!
+          chmod!
+        when :delete
+          delete!
+        end
+      end
+
+      protected
+
+      def create!
+        return if ::File.exists? path
+        run_command! "mkdir #{"-p " if recursive}#{path}"
+      end
+
+      def delete!
+        return if not ::File.exists? path
+        run_command! "rm -rf #{path}"
+      end
+
+      def chown!
+        return unless owner or group
+        if ::File.exists? path
+          cmd = "chown #{(group.nil?) ? owner : "#{owner}:#{group}"} #{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 unexpected_failure(message, reason)
+        print_error(message, {
+          path: path,
+          reason: reason
+        })
+      end
+
+    end
+  end
+end