hookit 0.7.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 37abbf6a175d07a169c2671f0bb48c160206d177
+  data.tar.gz: a1bb68175a4cc828109a2ce6c0240b9ef7baef67
+SHA512:
+  metadata.gz: 2c3bcf3b055ebc427aa0c1110967ed85114ddb935bbe6ec64409e03eb1ad11605e25c4141c2c3c765b16cc6028c4898503d38b94a5fdb8f8eab4077bad5fb908
+  data.tar.gz: 75f85243cf7e675be73f22cff3f481a96433d06c9aab4a0762ad317efec47e1322e5bbd2c10b05f51b0e5fc5b596b688914e07420e0883df149c2224eb04cbc4

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hookit.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Pagoda Box
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,3 @@
+# Hookit
+
+Hookit is the framework to provide hookit scripts with re-usable components and resources via an elegant dsl

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+desc "Create tag v#{Hookit::VERSION}"
+task :tag do
+  
+  puts "tagging version v#{Hookit::VERSION}"
+  `git tag -a v#{Hookit::VERSION} -m "Version #{Hookit::VERSION}"`
+  `git push origin --tags`
+  
+end

data/bin/hookit

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+MODULE_DIR = ENV['MODULE_DIR']  || "/opt/local/hookit/mod"
+LOG_LEVEL  = ENV['LOG_LEVEL']   || :error
+LOGFILE    = ENV['LOGFILE']     || '/var/log/hookit/hookit.log'
+
+hook = ARGV.shift
+
+if not hook
+  $stderr.puts "hook is required"
+  exit 1
+end
+
+# uncomment if dev only
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+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}"
+
+begin
+  load "#{MODULE_DIR}/hooks/#{hook}.rb"
+rescue LoadError
+  logger.error "hook: #{hook} does not exist"
+  $stderr.puts "hook: #{hook} does not exist"
+end

data/hookit.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hookit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hookit"
+  spec.version       = Hookit::VERSION
+  spec.authors       = ["Tyler Flint", "Greg Linton"]
+  spec.email         = ["tyler@pagodabox.com"]
+  spec.summary       = %q{Hookit is a framework to provide hookit scripts with re-usable components and resources via an elegant dsl.}
+  spec.description   = %q{The core framework to provide hookit scripts with re-usable components.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'tilt'
+  spec.add_dependency 'erubis'
+  spec.add_dependency 'oj'
+  spec.add_dependency 'multi_json', '>= 1.3'
+  spec.add_dependency 'excon'
+  spec.add_dependency 'faraday'
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+end

data/lib/hookit/converginator.rb

@@ -0,0 +1,141 @@
+module Hookit
+  class Converginator
+    
+    def initialize(map, list)
+      @map = map
+      @list = list
+    end
+
+    def converge!
+      output = {}
+      @map.each do |key, template|
+        if @list.key? key
+          output[key] = converge_value template, @list[key]
+        else
+          output[key] = template[:default]
+        end
+      end
+      output
+    end
+
+    def converge_value(template, value)
+      if template[:type] == :array
+        value = sanitize_array(template, value)
+      end
+
+      if valid? template, value
+        value
+      else
+        template[:default]
+      end
+    end
+
+    def sanitize_array(template, value)
+
+      case template[:of]
+      when :byte
+        value = [value] if ( valid_byte? value )
+      when :file
+        value = [value] if ( valid_file? value )
+      when :folder
+        value = [value] if ( valid_folder? value )
+      when :integer
+        value = [value] if ( valid_integer? value )
+      when :on_off
+        value = [value] if ( valid_on_off? value )
+      when :string
+        value = [value] if ( valid_string? value )
+      end
+      value
+    end
+
+    def valid?(template, value)
+      valid_type?(template, value) and valid_value?(template, value)
+    end
+
+    def valid_type?(template, value)
+      case template[:type]
+      when :array
+        valid_array? template, value
+      when :byte
+        valid_byte? value
+      when :file
+        valid_file? value
+      when :folder
+        valid_folder? value
+      when :hash
+        valid_hash? value
+      when :integer
+        valid_integer? value
+      when :on_off
+        valid_on_off? value
+      when :string
+        valid_string? value
+      end
+    end
+
+    def valid_value?(template, value)
+
+      return true if not template.key? :from
+
+      if template[:type] == :array
+        !( value.map {|element| template[:from].include? element} ).include? false
+      else
+        template[:from].include? value
+      end
+    end
+
+    def valid_string?(element)
+      element.is_a? String
+    end
+   
+    def valid_array?(template, value)
+
+      return false if not value.is_a? Array
+
+      return true if not template.key? :of
+
+      case template[:of]
+      when :byte
+        !( value.map {|element| valid_byte? element} ).include? false
+      when :file
+        !( value.map {|element| valid_file? element} ).include? false
+      when :folder
+        !( value.map {|element| valid_folder? element} ).include? false
+      when :integer
+        !( value.map {|element| valid_integer? element} ).include? false
+      when :on_off
+        !( value.map {|element| valid_on_off? element} ).include? false
+      when :string
+        !( value.map {|element| valid_string? element} ).include? false
+      else
+        true
+      end
+    end
+   
+    def valid_hash?(value)
+      value.is_a? Hash
+    end
+   
+    def valid_integer?(value)
+      value.is_a? Integer || (value.to_i.to_s == value.to_s)
+    end
+   
+    def valid_file?(value)
+      value =~ /^\/?[^\/]+(\/[^\/]+)*$/
+    end
+   
+    def valid_folder?(value)
+      value =~ /^\/?[^\/]+(\/[^\/]+)*\/?$/
+    end
+   
+    def valid_on_off?(value)
+      ['true', 'false', 'On', 'on', 'Off', 'off', '1', '0'].include? value.to_s
+    end
+   
+    def valid_byte?(value)
+      value.to_s =~ /^\d+[BbKkMmGgTt]?$/
+    end
+
+  end
+end

data/lib/hookit/db.rb

@@ -0,0 +1,37 @@
+require 'oj'
+require 'multi_json'
+require 'fileutils'
+
+module Hookit
+  class DB
+    
+    DEFAULT_PATH = '/var/db/hookit/db.json'
+
+    def initialize(path=nil)
+      @path = path || DEFAULT_PATH
+    end
+
+    def fetch(key)
+      data[key]
+    end
+
+    def put(key, value)
+      data[key] = value
+      save
+    end
+
+    def load
+      ::MultiJson.load(::File.read(@path)) rescue {}
+    end
+
+    def save
+      ::FileUtils.mkdir_p(File.dirname(@path))
+      ::File.write(@path, ::MultiJson.dump(data))
+    end
+
+    def data
+      @data ||= load
+    end
+
+  end
+end

data/lib/hookit/error.rb

@@ -0,0 +1,8 @@
+module Hookit
+  module Error
+    class UnexpectedExit < StandardError; end
+    class UnknownAction < StandardError; end
+    class UnsupportedPlatform < StandardError; end
+    class UnsupportedOption < StandardError; end
+  end
+end

data/lib/hookit/exit.rb

@@ -0,0 +1,23 @@
+module Hookit
+  module Exit
+    SUCCESS      = 0
+    ERROR        = 1
+    ERROR_RETRY  = 2
+    ERROR_ENOMEM = 3
+    WAIT_2       = 11
+    WAIT_4       = 12
+    WAIT_8       = 13
+    WAIT_16      = 14
+    WAIT_32      = 15
+    WAIT_64      = 16
+    WAIT_128     = 17
+    WAIT_256     = 18
+    WAIT_512     = 19
+    WAIT_1024    = 20
+    ABORT        = 21
+    ABORT_MSG    = 22
+    SUCCESS_FLAG = 31
+    SUCCESS_MSG  = 32
+    WTF          = 255
+  end
+end

data/lib/hookit/helper/cron.rb

@@ -0,0 +1,42 @@
+module Hookit
+  module Helper
+    module Cron
+      
+      MINUTES = 59
+      HOURS   = 23
+      DAYS    = 31
+      MONTHS  = 12
+      WEEKDAY = 7
+      
+      def sanitize_cron(cron)
+      
+        time = cron.split(' ')
+        
+        time[0] = compatible_cron(time[0],MINUTES)
+        time[1] = compatible_cron(time[1],HOURS)
+        time[2] = compatible_cron(time[2],DAYS, 1)
+        time[3] = compatible_cron(time[3],MONTHS, 1)
+        time[4] = compatible_cron(time[4],WEEKDAY)
+      
+        time.join(' ')
+      end
+      
+      protected
+
+      # converts */x cron format into solaris compatible format
+      def compatible_cron(time, limit, start = 0)
+        if time =~ /\//
+          increment = time.split('/')[1].to_i
+          x, y      = start, []
+          for i in 0..limit/increment
+            y[i] = x
+            x    +=increment
+          end
+          time = y.join(',')
+        end
+        time
+      end
+
+    end
+  end
+end

data/lib/hookit/helper/nfs.rb

@@ -0,0 +1,113 @@
+module Hookit
+  module Helper
+    module NFS
+
+      def sanitize_network_dirs(payload)
+        net_dirs = net_dirs(payload)
+
+        net_dirs.each do |component, dirs|
+          net_dirs[component] = clean_writables(dirs)
+        end
+
+        net_dirs
+      end
+
+      def net_dirs(payload)
+        key     = payload[:storage].keys.first
+        boxfile = payload[:boxfile]
+
+        if boxfile[:shared_writable_dirs]
+          {
+            key => boxfile[:shared_writable_dirs]
+          }
+        elsif boxfile[:network_dirs].is_a? String
+          {
+            key => [boxfile[:network_dirs]]
+          }
+        elsif boxfile[:network_dirs].is_a? Array
+          {
+            key => boxfile[:network_dirs]
+          }
+        else
+          boxfile[:network_dirs] ||= {}
+        end
+
+      end
+
+      def clean_writables(dirs)
+        begin
+          dirs = dirs.map{|i| i.to_s}
+        rescue
+          dirs = [dirs].map{|i| i.to_s}
+        end
+        dirs = remove_empty(dirs)
+        dirs = filter_offensive(dirs)
+        dirs = strip_leading_slash(dirs)
+        dirs = strip_trailing_slash(dirs)
+        dirs = remove_nested(dirs)
+        dirs.uniq
+      end
+     
+      def remove_empty(dirs)
+        dirs.inject([]) do |res, elem|
+          res << elem if elem && elem != ""
+          res
+        end
+      end
+     
+      def filter_offensive(dirs)
+        dirs.inject([]) do |res, elem|
+          if elem[0] != '.'
+            # ensure not going up a directory
+            # ensure spaces are intended
+            # ensure directory is not . or /
+            unless elem =~ /(\*|\.?\.\/|(?<!\\)\s)|^\.$|^\/$/
+              res << elem
+            end
+          end
+          res
+        end       
+      end
+     
+      def strip_leading_slash(dirs)
+        dirs.inject([]) do |res, elem|
+          if elem[0] == '/'
+            elem.slice!(0)
+          end 
+          res << elem
+        end
+      end
+      
+      def strip_trailing_slash(dirs)
+        dirs.inject([]) do |res, elem|
+          if elem[-1] == '/'
+            elem.slice!(-1)
+          end
+          res << elem
+        end
+      end
+     
+      # this removes nested mounts like:
+      # tmp/
+      # tmp/cache/
+      # tmp/assets/
+      # 
+      # and keeps tmp/
+      def remove_nested(dirs)
+        dirs.sort!
+        dirs.inject([]) do |res, elem|
+          overlap = false
+          # now make sure parents dont contain children
+          res.each do |parent|
+            if elem =~ /^#{parent}\//
+              overlap = true
+            end
+          end
+          res << elem if not overlap
+          res
+        end
+      end
+
+    end
+  end
+end

data/lib/hookit/helper/shell.rb

@@ -0,0 +1,35 @@
+module Hookit
+  module Helper
+    module Shell
+      
+      def sanitize_shell_vars(vars)
+        vars.inject({}) do |res, (key,value)|
+          res[escape_shell_string(key.to_s)] = escape_shell_string(value.to_s)
+          res
+        end
+      end
+
+      # strategy:
+      # 1- escape the escapes
+      # 2- escape quotes
+      # 3- escape backticks
+      # 4- escape semicolons
+      # 5- escape ampersands
+      # 6- escape pipes
+      # 7- escape dollar signs
+      # 8- escape spaces
+      def escape_shell_string(str)
+        str = str.gsub(/\\/, "\\\\\\")
+        str = str.gsub(/"/, "\\\"")
+        str = str.gsub(/`/, "\\`")
+        str = str.gsub(/;/, "\\;")
+        str = str.gsub(/&/, "\\&")
+        str = str.gsub(/\|/, "\\|")
+        str = str.gsub(/\$/, "\\$")
+        str = str.gsub(/ /, "\\ ")
+        str
+      end
+
+    end
+  end
+end

data/lib/hookit/helper/xml.rb

@@ -0,0 +1,25 @@
+module Hookit
+  module Helper
+    module XML
+      
+      def sanitize_xml_vars(vars)
+        vars.inject({}) do |res, (key,value)|
+          res[sanitize_xml_string(key.to_s)] = sanitize_xml_string(value.to_s)
+          res
+        end
+      end
+
+      protected
+
+      def sanitize_xml_string(str)
+        str = str.gsub(/&/, '&')
+        str = str.gsub(/</, '&lt;')
+        str = str.gsub(/>/, '&gt;')
+        str = str.gsub(/"/, '&quot;')
+        str = str.gsub(/'/, '&apos;')
+        str
+      end
+
+    end
+  end
+end

data/lib/hookit/helper.rb

@@ -0,0 +1,9 @@
+require 'hookit/helper/nfs'
+require 'hookit/helper/shell'
+require 'hookit/helper/xml'
+require 'hookit/helper/cron'
+
+module Hookit
+  module Helper
+  end
+end

data/lib/hookit/hook.rb

@@ -0,0 +1,102 @@
+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)
+      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 logvac
+      @logvac ||= Hookit::Logvac.new({
+        app:    payload[:app][:id],
+        token:  payload[:app][:logvac_token],
+        deploy: payload[:deploy][:id]
+      })
+    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