hem 1.0.1.beta1

data/hem.gemspec

@@ -0,0 +1,47 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'hem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hem"
+  spec.version       = Hem::VERSION.gsub('-', '.')
+  spec.authors       = ["Mike Simons"]
+  spec.email         = ["msimons@inviqa.com"]
+  spec.description   = %q{Inviqan toolbelt}
+  spec.summary       = %q{Inviqan toolbelt}
+  spec.homepage      = ""
+
+  # This file will get interpretted at runtime due to Bundler.setup
+  # Without the $HEM_ARGV check (set in bin/hem) fatal: not a git repository errors show up
+  spec.files         = `git ls-files`.split($/) if ENV['HEM_BUILD'] == '1'
+  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 "slop", "~> 3.4.7"
+  spec.add_dependency "highline", "~> 1.6.20"
+  spec.add_dependency "rake", "~> 10.1.1"
+  spec.add_dependency "deepstruct", "~> 0.0.5"
+  spec.add_dependency "semantic", "~> 1.3.0"
+  spec.add_dependency "aws-sdk", "~> 2.0.24"
+  spec.add_dependency "ruby-progressbar", "~> 1.4.1"
+  spec.add_dependency "teerb", "~> 0.0.1"
+  spec.add_dependency "net-ssh-simple", "~> 1.6.3"
+  spec.add_dependency "pry", "~> 0.9.12"
+  spec.add_dependency "octokit", "~> 3.0"
+
+  # This prevents Bundler.setup from complaining that rubygems did not install dev deps
+  # If you want to run dev deps you need to ensure HEM_ENV=dev is set for bundle install & bundle exec
+  if ENV['HEM_ENV'] == 'dev'
+    spec.add_development_dependency "aruba", "~> 0.5.4"
+    spec.add_development_dependency "rspec", "~> 2.14.1"
+    spec.add_development_dependency "fakefs", "~> 0.5.0"
+    spec.add_development_dependency "rr", "~> 1.1.2"
+    spec.add_development_dependency "guard", "~> 2.2.5"
+    spec.add_development_dependency "guard-rspec", "~> 4.2.4"
+    spec.add_development_dependency "guard-cucumber", "~> 1.4.1"
+    spec.add_development_dependency "simplecov", "~> 0.7.1"
+  end
+end

data/lib/hem/asset_applicator.rb

@@ -0,0 +1,33 @@
+module Hem
+  class << self
+    attr_accessor :asset_applicators
+
+    # Utility method to access (with initialization) the asset applicator registry.
+    # This allows you to register new asset applicator methods on a per-project basis.
+    # For example:
+    #
+    #     Hem.asset_applicators.register /.*\.zip/ do |file|
+    #       Dir.chdir File.dirname(file) do
+    #         shell "unzip", file
+    #       end
+    #     end
+    #
+    # @see Hem::AssetApplicatorRegistry
+    # @return [Hem::AssetApplicatorRegistry] Applicator registry cotnainer
+    def asset_applicators
+      @asset_applicators ||= AssetApplicatorRegistry.new
+    end
+  end
+
+  private
+
+  # Thin wrapper over a hash to provide a means to "register" asset applicators
+  class AssetApplicatorRegistry < Hash
+    # Register a new asset applicator
+    # @param [Regexp] Pattern to match against asset filename.
+    # @yield The block to be executed when an asset matches the pattern.
+    def register pattern, &block
+      self[pattern] = block
+    end
+  end
+end

data/lib/hem/asset_applicators/files.rb

@@ -0,0 +1,5 @@
+# Built in applicators
+Hem.asset_applicators.register /.*\.files\.(tgz|tar\.gz|tar\.bz2)/ do |file|
+  Hem.ui.title "Applying file dump (#{file})"
+  vm_shell "tar -xvf #{file.shellescape}"
+end

data/lib/hem/asset_applicators/sqldump.rb

@@ -0,0 +1,38 @@
+# Built in applicators
+Hem.asset_applicators.register /.*\.sql\.gz/ do |file|
+  matches = file.match(/^([^\.]+).*\.sql\.gz/)
+  db = File.basename(matches[1])
+
+  status = {
+    :db_exists => false,
+    :db_has_tables => false
+  }
+
+  begin
+    result = shell(vm_mysql(:db => db).pipe('SHOW TABLES; SELECT FOUND_ROWS();', :on => :vm), :capture => true)
+    status[:db_exists] = true
+    status[:db_has_tables] = !(result.split("\n").last.strip == '0')
+  rescue Hem::ExternalCommandError
+    # This will fail later with a more useful error message
+  end
+
+  if status[:db_exists] && status[:db_has_tables]
+    Hem.ui.warning "Already applied (#{file})"
+    next
+  end
+
+  if status[:db_exists] && !status[:db_has_tables]
+    # Db exists but is empty
+    shell(vm_mysql(:mysql => 'mysqladmin', :append => " --force drop #{db.shellescape}"))
+  end
+
+  begin
+    Hem.ui.title "Applying mysqldump (#{file})"
+    shell(vm_mysql(:mysql => 'mysqladmin', :append => " create #{db.shellescape}"))
+    shell(vm_mysql(:auto_echo => false, :db => db) < "zcat #{file.shellescape}")
+  rescue Hem::ExternalCommandError => exception
+    Hem.ui.error "Could not apply #{file} due to the following error:\n"
+    Hem.ui.error File.read(exception.output.path).strip
+    raise exception
+  end
+end

data/lib/hem/cli.rb

@@ -0,0 +1,252 @@
+module Hem
+
+  class << self
+    attr_accessor :cli
+  end
+
+  # Utility error to shortcut exit routine within actions
+  class Halt < Error
+  end
+
+  # Main application class
+  class Cli
+    include Hem::Logging
+
+    attr_accessor :slop, :help_formatter
+
+    # @param [Hash] Initialization accepts several options in a hash:
+    #     - :slop - Slop instance
+    #     - :help - Help formatter instance
+    #     - :host_check - Host check invocation class
+    #
+    # :help and :host_check are only used by tests.
+    # :slop is used to ensure low-level args parsed in bin/hem are propagated to the application
+    def initialize opts = {}
+      @opts = opts
+      @slop = opts[:slop] || Slop.new
+      @help_formatter = opts[:help] || Hem::HelpFormatter.new(@slop)
+      @help_opts = {}
+      @host_check = opts[:host_check] || Hem::Lib::HostCheck
+    end
+
+    # entry point for application
+    # @param [Array] Arguments from ARGV. Defaults to ARGV
+    def start args = ARGV
+      load_user_config
+      load_builtin_tasks
+      load_hemfiles
+      load_project_config
+      Hem.chefdk_compat
+
+      tasks = structure_tasks Hem::Metadata.metadata.keys
+      define_global_opts @slop
+
+      begin
+        # Parse out global args first
+        @slop.parse! args
+        opts = @slop.to_hash
+
+        perform_host_checks unless opts[:'skip-host-checks']
+
+        @help_opts[:all] = opts[:all]
+
+        @slop.add_callback :empty do
+          show_help
+        end
+
+        # Necessary to make command level help work
+        args.push "--help" if @slop.help?
+
+        @help_formatter.command_map = define_tasks(tasks, @slop)
+
+        remaining = @slop.parse! args
+        raise Hem::InvalidCommandOrOpt.new remaining.join(" "), self if remaining.size > 0
+
+        show_help if @slop.help?
+      rescue Halt
+        # NOP
+      end
+
+      return 0
+    end
+
+    # Display help and exit
+    # @param [Hash] Options to apss to help formatter.
+    # Options are mostly used for filtering
+    def show_help(opts = {})
+      Hem.ui.info @help_formatter.help(@help_opts.merge(opts))
+      halt
+    end
+
+    private
+
+    def load_builtin_tasks
+      require 'hem/tasks/assets'
+      require 'hem/tasks/config'
+      require 'hem/tasks/deps'
+      require 'hem/tasks/exec'
+      require 'hem/tasks/ops'
+      require 'hem/tasks/pr'
+      require 'hem/tasks/seed'
+      require 'hem/tasks/self'
+      require 'hem/tasks/shell_init'
+      require 'hem/tasks/system'
+      require 'hem/tasks/system/completions'
+      require 'hem/tasks/tools'
+      require 'hem/tasks/vm'
+    end
+
+    def load_user_config
+      Hem.user_config = Hem::Config::File.load Hem.user_config_file
+    end
+
+    def load_project_config
+      if Hem.in_project?
+        Hem.project_config = Hem::Config::File.load Hem.project_config_file
+      else
+        Hem.project_config = DeepStruct.wrap({})
+      end
+    end
+
+    def load_hemfiles
+      if Hem.in_project? && File.exists?(Hem.hemfile_path)
+        logger.debug("cli: Loading hemfile @ #{Hem.hemfile_path}")
+        eval(File.read(Hem.hemfile_path), TOPLEVEL_BINDING, Hem.hemfile_path)
+      end
+
+      if File.exists?(Hem.user_hemfile_path)
+        logger.debug("cli: Loading hemfile @ #{Hem.user_hemfile_path}")
+        eval(File.read(Hem.user_hemfile_path), TOPLEVEL_BINDING, Hem.user_hemfile_path)
+      end
+    end
+
+    def perform_host_checks
+      checks = [
+        'vagrant.*',
+        'ssh_present',
+        'git_present'
+      ]
+
+      @host_check.check(
+        :filter => /#{checks.join('|')}/,
+        :raise => true
+      )
+    end
+
+    def define_global_opts slop
+      slop.on '-a', '--all', 'Show hidden commands'
+      slop.on '-h', '--help', 'Display help'
+
+      slop.on '-v', '--version', 'Print version information' do
+        Hem.ui.info "Hem version #{Hem::VERSION}"
+        halt
+      end
+    end
+
+    def halt
+      raise Halt.new
+    end
+
+    # Takes a nested hash of commands and creates nested Slop instances populated with metadata.
+    #
+    # @param [Hash] A nested hash of namespaces & commands.
+    # @param [Slop] A slop instance on which to define tasks.
+    # @param [Array] Stack of string names of parental namespaces.
+    # @param [Hash] Hash of "namespace:command" => Slop instances.
+    # @return [Hash] Hash of "namespace:command" => Slop instances.
+    def define_tasks structured_list, scope, stack = [], map = {}
+      structured_list.each do |k, v|
+        name = (stack + [k]).join(':')
+        new_stack = stack + [k]
+        logger.debug("cli: Defined #{name}")
+        map[name] = if v.size == 0
+          define_command(name, scope, new_stack)
+        else
+          define_namespace(name, scope, new_stack, v, map)
+        end
+      end
+      return map
+    end
+
+    # Map rake namespace to a Slop command
+    def define_namespace name, scope, stack, subtasks, map
+      metadata = Hem::Metadata.metadata[name]
+      hem = self
+      new_scope = nil
+
+      scope.instance_eval do
+        new_scope = command stack.last do
+
+          description metadata[:desc]
+          long_description metadata[:long_desc]
+          hidden metadata[:hidden]
+          project_only metadata[:project_only]
+
+          # NOP; run runs help anyway
+          on '-h', '--help', 'Display help' do end
+
+          run do |opts, args|
+            hem.show_help(target: name)
+          end
+        end
+      end
+
+      define_tasks subtasks, new_scope, stack, map
+      return new_scope
+    end
+
+    # Map rake task to a Slop command
+    def define_command name, scope, stack
+      metadata = Hem::Metadata.metadata[name]
+      hem = self
+      new_scope = nil
+
+      scope.instance_eval do
+        new_scope = command stack.last do
+          task = Rake::Task[name]
+
+          description metadata[:desc]
+          long_description metadata[:long_desc]
+          arg_list task.arg_names
+          hidden metadata[:hidden]
+          project_only metadata[:project_only]
+
+          metadata[:opts].each do |opt|
+            on *opt
+          end if metadata[:opts]
+
+          on '-h', '--help', 'Display help' do
+            hem.show_help(target: name)
+          end
+
+          run do |opts, args|
+            Dir.chdir Hem.project_path if Hem.in_project?
+            raise ::Hem::ProjectOnlyError.new if opts.project_only && !Hem.in_project?
+            task.opts = opts.to_hash.merge({:_unparsed => hem.slop.unparsed})
+            raise ::Hem::MissingArgumentsError.new(name, args, hem) if args && task.arg_names.length > args.length
+            task.invoke *args
+            args.pop(task.arg_names.size)
+            task.opts = nil
+          end
+        end
+      end
+
+      return new_scope
+    end
+
+    # Expand flat task list in to hierarchy (non-recursive)
+    # @param [Array] List of strings with entries of the form "namespace1:namespace2:task"
+    def structure_tasks list
+      out = {}
+      list.each do |name|
+        ref = out
+        name = name.split(":")
+        name.each do |n|
+          ref[n] ||= {}
+          ref = ref[n]
+        end
+      end
+      out
+    end
+  end
+end

data/lib/hem/config/file.rb

@@ -0,0 +1,22 @@
+module Hem
+  module Config
+    class File
+      def self.save(file, config)
+        require 'yaml'
+        config = config.unwrap if config.public_methods.include? :unwrap
+        dir = ::File.dirname file
+        FileUtils.mkdir_p dir unless ::File.exists? dir
+        ::File.open(file, 'w+') do |f|
+          f.puts config.to_yaml
+        end
+      end
+
+      def self.load(file)
+        require 'yaml'
+        config = ::File.exists?(file) ? YAML.load_file(file) : {}
+        raise "Invalid hem configuration (#{file})" unless config
+        return DeepStruct.wrap(config)
+      end
+    end
+  end
+end

data/lib/hem/config.rb

@@ -0,0 +1,5 @@
+module Hem
+  class << self
+    attr_accessor :project_config, :user_config
+  end
+end

data/lib/hem/error_handlers/debug.rb

@@ -0,0 +1,12 @@
+module Hem
+  module ErrorHandlers
+    class Debug
+      include Hem::ErrorHandlers::ExitCodeMap
+
+      def handle error
+        Hem.ui.error "\n(#{error.class}) #{error.message}\n\n#{(error.backtrace || []).join("\n")}"
+        return EXIT_CODES[error.class.to_s] || DEFAULT_EXIT_CODE
+      end
+    end
+  end
+end

data/lib/hem/error_handlers/exit_code_map.rb

@@ -0,0 +1,17 @@
+module Hem
+  module ErrorHandlers
+    module ExitCodeMap
+      DEFAULT_EXIT_CODE = 128
+      EXIT_CODES = {
+        'Interrupt' => 1,
+        'Hem::ExternalCommandError' => 3,
+        'Hem::InvalidCommandOrOpt' => 4,
+        'Hem::MissingArgumentsError' => 5,
+        'Hem::UserError' => 6,
+        'Hem::ProjectOnlyError' => 7,
+        'Hem::HostCheckError' => 8,
+        'Hem::Error' => 9
+      }
+    end
+  end
+end

data/lib/hem/error_handlers/friendly.rb

@@ -0,0 +1,58 @@
+module Hem
+  module ErrorHandlers
+    class Friendly
+      include Hem::ErrorHandlers::ExitCodeMap
+
+      def handle error
+        require 'tmpdir'
+        log_file = File.join(Dir.tmpdir, 'hem_error.log')
+
+        # Not possible to match Interrupt class unless we use class name as string for some reason!
+        case error.class.to_s
+          when "Interrupt"
+            Hem.ui.warning "\n\nCaught Interrupt. Aborting\n"
+          when "Hem::ExternalCommandError"
+            FileUtils.cp error.output.path, log_file
+
+            File.open(log_file, "a") do |file|
+              file.write "\n(#{error.class}) #{error.message}\n\n#{error.backtrace.join("\n")}"
+            end
+
+            Hem.ui.error <<-ERROR
+
+  The following external command appears to have failed (exit status #{error.exit_code}):
+    #{error.command}
+
+  The output of the command has been logged to #{log_file}
+            ERROR
+          when "Hem::InvalidCommandOrOpt"
+            Hem.ui.error "\n#{error.message}"
+            Hem.ui.info error.cli.help_formatter.help if error.cli
+          when "Hem::MissingArgumentsError"
+            Hem.ui.error "\n#{error.message}"
+            Hem.ui.info error.cli.help_formatter.help(target: error.command) if error.cli
+          when "Hem::UserError"
+            Hem.ui.error "\n#{error.message}\n"
+          when "Hem::ProjectOnlyError"
+            Hem.ui.error "\nHem requires you to be in a project directory for this command!\n"
+          when "Hem::HostCheckError"
+            Hem.ui.error "\nHem has detected a problem with your system configuration:\n"
+            Hem.ui.warning error.advice.gsub(/^/, '  ')
+          when "Hem::Error"
+            Hem.ui.error "\n#{error.message}\n"
+          else
+            File.write(log_file, "(#{error.class}) #{error.message}\n\n#{error.backtrace.join("\n")}")
+            Hem.ui.error <<-ERROR
+
+  An unexpected error has occured:
+    #{error.message}
+
+  The backtrace has been logged to #{log_file}
+            ERROR
+        end
+
+        return EXIT_CODES[error.class.to_s] || DEFAULT_EXIT_CODE
+      end
+    end
+  end
+end

data/lib/hem/errors.rb

@@ -0,0 +1,89 @@
+module Hem
+  class Error < StandardError
+    attr_reader :exit_code
+  end
+
+  class RubyVersionError < Error
+    def initialize
+      super("Ruby 1.9+ is required to run hem")
+    end
+  end
+
+  class MissingDependencies < Error
+    def initialize deps
+      deps.map! { |dep| " - #{dep}"}
+      super("Hem requires the following commands to be available on your path:\n\n" + deps.join("\n"))
+    end
+  end
+
+  class InvalidCommandOrOpt < Error
+    attr_accessor :command, :cli
+    def initialize command, cli = nil
+      @command = command
+      @cli = cli
+      super("Invalid command or option specified: '#{command}'")
+    end
+  end
+
+  class MissingArgumentsError < Error
+    attr_accessor :command, :cli
+    def initialize command, args, cli = nil
+      @command = command
+      @args = args
+      @cli = cli
+      super("Not enough arguments for #{command}")
+    end
+  end
+
+  class ExternalCommandError < Error
+    attr_accessor :command, :exit_code, :output
+
+    def initialize command, exit_code, output
+      @command = command
+      @exit_code = exit_code
+      @output = output
+      super("'#{command}' returned exit code #{exit_code}")
+    end
+  end
+
+  class UserError < Error
+  end
+
+  class ProjectOnlyError < Error
+  end
+
+  class NonInteractiveError < Error
+    def initialize question
+      @question = question
+      super("A task requested input from the user but hem is in non-interactive mode")
+    end
+  end
+
+  class MissingDependency < Error
+    def initialize dep
+      @dependency = dep
+      super("A tool that hem depends on could not be detected (#{dep})")
+    end
+  end
+
+  class HostCheckError < Error
+    attr_accessor :summary, :advice
+    def initialize summary, advice
+      @summary = summary
+      @advice = advice
+      super("Host check failed: #{summary}")
+    end
+  end
+
+  class UndefinedEditorError < Error
+    def initialize
+      super('You need to define a preferred editor, either in your hem config or with the EDITOR environment variable')
+    end
+  end
+
+  class GithubAuthenticationError < Error
+  end
+
+  class GithubApiError < Error
+  end
+end