hookit 0.7.11

data/lib/hookit/logger.rb

@@ -0,0 +1,58 @@
+module Hookit
+  class Logger
+    
+    attr_reader :log_file, :log_level
+
+    def initialize(file, level)
+      @log_file  = file   || '/var/log/hookit/hookit.log'
+      @log_level = level  || :error
+    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/logvac.rb

@@ -0,0 +1,34 @@
+require 'faraday'
+
+module Hookit
+  class Logvac
+    
+    def initialize(opts)
+      @app    = opts[:app]
+      @deploy = opts[:deploy]
+      @token  = opts[:token]
+    end
+
+    def post(message)
+      connection.post("/deploy/#{@app}") do |req|
+        req.headers[:x_auth_token] = @token
+        req.headers[:x_deploy_id]  = @deploy
+        req.body = message
+      end
+    end
+    alias :print :post
+
+    def puts(message='')
+      post("#{message}\n")
+    end
+
+    protected
+
+    def connection
+      @connection ||= Faraday.new(url: 'http://logvac.admin.pagodabox.io:6361') do |faraday|
+        faraday.adapter :excon
+      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/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,9 @@
+require 'hookit/platform/base'
+require 'hookit/platform/smartos'
+require 'hookit/platform/ubuntu'
+
+module Hookit
+  module Platform
+    
+  end
+end

data/lib/hookit/platforms.rb

@@ -0,0 +1,2 @@
+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,105 @@
+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)
+        `#{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/cron.rb

@@ -0,0 +1,26 @@
+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
+          $stderr.puts 'Timed out running cron! Consider using a worker.'
+        end
+      end
+      
+    end
+  end
+end

data/lib/hookit/resource/directory.rb

@@ -0,0 +1,67 @@
+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
+        cmd = "mkdir #{"-p " if recursive}#{path}"
+        `#{cmd}`
+        code = $?.exitstatus
+        if code != 0
+          raise Hookit::Error::UnexpectedExit, "#{cmd} failed with exit code '#{code}'"
+        end
+      end
+
+      def delete!
+        return if not ::File.exists? path
+        cmd = "rm -rf #{path}"
+        `#{cmd}`
+        code = $?.exitstatus
+        if code != 0
+          raise Hookit::Error::UnexpectedExit, "#{cmd} failed with exit code '#{code}'"
+        end
+      end
+
+      def chown!
+        return unless owner or group
+        if ::File.exists? path
+          `chown #{(group.nil?) ? owner : "#{owner}:#{group}"} #{path}`
+        end
+      end
+
+      def chmod!
+        if ::File.exists? path and mode
+          ::File.chmod(mode, path)
+        end
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/execute.rb

@@ -0,0 +1,148 @@
+require 'timeout'
+
+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 :validator
+      field :ignore_exit
+
+      actions :run
+      default_action :run
+
+      def initialize(name)
+        command name unless command
+        timeout 3600
+        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
+            raise "ERROR: execute resource \"#{name}\" failed validation!"
+          end
+        else
+          res
+        end
+      end
+
+      def run!
+        Timeout::timeout(timeout) do
+          res = `#{cmd}`
+          code = $?.exitstatus
+          unexpected_exit(code) unless code == returns
+          validate! res
+        end
+      end
+
+      def stream!
+        result = ""
+
+        STDOUT.sync = STDERR.sync = true # don't buffer stdout/stderr
+
+        ::IO.popen(cmd, :err=>[:child, :out]) do |out|
+          eof = false
+          until eof do
+            begin
+              chunk = out.readpartial(4096)
+              if on_data and on_data.respond_to? :call
+                on_data.call(chunk)
+              end
+            rescue EOFError
+              eof = true
+            end
+            result << chunk.to_s
+          end
+        end
+
+        code = $?.exitstatus
+        unexpected_exit(code) unless code == returns
+
+        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)
+        raise Hookit::Error::UnexpectedExit, "'#{name}' exited with #{res}, expected #{returns}" unless ignore_exit
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/file.rb

@@ -0,0 +1,71 @@
+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!
+        ::File.write path, (content || "")
+      end
+
+      def create_if_missing!
+        if not ::File.exists? path
+          create!
+        end
+      end
+
+      def delete!
+        ::File.delete path
+      end
+
+      def chown!
+        return unless owner or group
+        if ::File.exists? path
+          `chown #{(group.nil?) ? owner : "#{owner}:#{group}"} #{path}`
+        end
+      end
+
+      def chmod!
+        if ::File.exists? path and mode
+          ::File.chmod(mode, path)
+        end
+      end
+
+      def touch!
+        `touch -c #{path}`
+      end
+
+    end
+  end
+end

data/lib/hookit/resource/hook_file.rb

@@ -0,0 +1,80 @@
+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!
+        ::File.write path, render
+      end
+
+      def create_if_missing!
+        if not ::File.exists? path
+          create!
+        end
+      end
+
+      def delete!
+        ::File.delete path
+      end
+
+      def chown!
+        return unless owner or group
+        `chown #{(group.nil?) ? owner : "#{owner}:#{group}"} #{path}`
+      end
+
+      def chmod!
+        ::File.chmod(mode, path) if mode
+      end
+
+      def touch!
+        `touch -c #{path}`
+      end
+
+      def render
+        ::File.read("#{file_dir}/#{source}")
+      end
+
+      def file_dir
+        "#{module_root}/files"
+      end
+
+      def module_root
+        dict[:module_root]
+      end
+
+    end
+  end
+end