micro-hookit 0.12.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '096ca77b30d22da4e013840aec4e19ab67b9bcc59d9cee60cbba34d34295fffb'
+  data.tar.gz: e53956fa759ff1f1f26748dd271a917e43e21174ccd5239449db36fab3f2ea08
+SHA512:
+  metadata.gz: e3e75da419b563dbe31af392d77c7502f3bd6dc755573d7eff0ad64032713736a1b851fc0eb67d8c7ba138769080b5ffeabd7ead95eeaad3d5930376cf6b75e4
+  data.tar.gz: 2ade0269e7d1ed419a71a3d4591eba58c5fed350fe3627073739c20946bde85371628d57103c6697b6e1d7dcc07f244014095e78307b3799d98eebfa8d398d8e

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/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Microbox
+
+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,24 @@
+[![hookit logo](http://assets.microbox.cloud/readme-headers/hookit.png)](http://microbox.cloud/open-source#hookit)
+ [![Build Status](https://travis-ci.org/microbox/hookit.svg)](https://travis-ci.org/microbox/hookit)
+
+# Hookit
+
+A devops configuration management tool that responds to events, with a chef-like dsl.
+
+## Status
+
+Complete/Stable
+
+## TODO
+
+- documentation
+
+### Contributing
+
+Contributions to the hookit project are welcome and encouraged. hookit is a [Microbox](https://microbox.cloud) project and contributions should follow the [Microbox Contribution Process & Guidelines](https://docs.microbox.cloud/contributing/).
+
+### Licence
+
+Mozilla Public License Version 2.0
+
+[![open source](http://assets.microbox.cloud/open-src/microbox-open-src.png)](http://microbox.cloud/open-source)

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+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
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/hookit

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+begin
+  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
+rescue Exception => e
+  $stderr.puts "There has been an error."
+  $stderr.puts "If you choose to submit a ticket,"
+  $stderr.puts "please include the following backtrace."
+  $stderr.puts "======================================="
+  $stderr.puts e.message
+  $stderr.puts e.backtrace
+  $stderr.puts "======================================="
+  exit 1
+end

data/boxfile.yml

@@ -0,0 +1,2 @@
+run.config:
+  engine: ruby

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          = "micro-hookit"
+  spec.version       = Hookit::VERSION
+  spec.authors       = ["Hennik Hunsaker", "Tyler Flint", "Greg Linton"]
+  spec.email         = ["hennik@microbox.cloud"]
+  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      = "https://microbox.cloud/open-source"
+  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,165 @@
+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_hash(template, value)
+      temp = {}
+      template.each do |k, t|
+        if value.key? k
+          temp[k] = converge_value t, value[k]
+        else
+          temp[k] = t[:default]
+        end
+      end
+      temp
+    end
+
+    def converge_value(template, value)
+      if template[:type] == :array
+        value = sanitize_array(template, value)
+      end
+
+      if template[:type] == :array and template[:of] == :hash and template[:template]
+        value.map! {|v| converge_hash(template[:template], v)}
+      end
+
+      if template[:type] == :hash and template[:template]
+        value = converge_hash(template[: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 :hash
+        value = [value] if ( valid_hash? 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 || []) + (template[:default] || [])).uniq
+    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 :hash
+        !( value.map {|element| valid_hash? 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), symbolize_keys: true) 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,9 @@
+module Hookit
+  module Error
+    class MissingConfiguration < StandardError; end
+    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