bourdain 1.2.13

data/lib/bourdain/resources/checks/hooks.rb

@@ -0,0 +1,67 @@
+module Bourdain
+  module Checks
+
+    class HooksCheck < Check
+      usage :check, <<-END
+        Check the local copy of Kitchen hooks
+        hooks
+      END
+
+
+      def initialize _
+        super []
+        return unless require_chef!
+        check_hooks!
+      end
+
+
+
+    private
+      def check_hooks!
+        # Ensure we have an up-to-date copy of Kitchen hooks
+        hooks = File.join('utils', 'hooks')
+
+        ahead_of_remote = false
+        unless Dir.exists? hooks
+          log.warn  "Hm, I don't see a copy of Kitchen hooks. I'll fix that for you..."
+          %x| git clone git@git.bluejeansnet.com:kitchen-hooks.git #{hooks} |
+          log.info  "Your copy of Kitchen hooks is now up-to-date."
+
+        else
+          if youre_dirty? hooks
+            log.warn  "Your copy of Kitchen hooks is dirty."
+          elsif youre_ahead? hooks
+            log.warn  "Your copy of Kitchen hooks is ahead of the remote."
+            ahead_of_remote = true
+          elsif youre_behind? hooks
+            log.warn  "Hey, looks like your copy of Kitchen hooks is out-of-date. I'll fix that for you..."
+            Dir.chdir(bourdain) { %x| git pull | }
+            log.info  "Your copy of Kitchen hooks is now up-to-date."
+          else
+            log.info  "Your copy of Kitchen hooks looks up-to-date."
+          end
+        end
+
+        matches = File.read('Gemfile.lock').match(/kitchen_hooks \((.*?)\)$/)
+
+        if matches.nil?
+          log.warn "Couldn't find Kitchen hooks in your Gemfile lock. Something is amiss..."
+          error!
+
+        else
+          repo_version = matches[1].strip
+          local_version = File.read(File.join(hooks, 'VERSION')).strip
+
+          if repo_version == local_version
+            log.info "Your Chef repo is bundled with the latest Kitchen hooks."
+          elsif ahead_of_remote
+            # Don't worry about it, we've already warned them
+          elsif local_version < repo_version
+            log.error 'Your Chef repo is bundled with an older Kitchen hooks. Try "bundle update".'
+            error!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bourdain/resources/checks/ssh_config.rb

@@ -0,0 +1,61 @@
+require 'json'
+
+module Bourdain
+  module Checks
+
+    class SSHConfigCheck < Check
+      usage :check, <<-END
+        Ensure all nodes are enterened into the local SSH config
+        ssh_config
+      END
+
+
+      def initialize cookbook_config
+        super []
+        return unless require_chef!
+        check_ssh_config!
+      end
+
+
+
+    private
+      def check_ssh_config! ssh_config=File.join(ENV['HOME'], '.ssh', 'config')
+        unless File::exist?(ssh_config)
+          log.warn 'Skipping SSH config check. File does not exist: %s' % ssh_config.inspect
+          return
+        end
+
+        nodes = Dir[File.join('nodes', '*.json')]
+        nodes = nodes.map do |path|
+          JSON::parse File.read(path)
+        end
+
+        config = File.read(ssh_config)
+
+        hosts = []
+        config.lines.select do |l|
+          l =~ /Host (\S+)/
+          hosts << $1 if $1
+        end
+
+        unconfigured_nodes = nodes.select do |n|
+          !hosts.include? n['name']
+        end
+
+        File.open(ssh_config, 'a') do |f|
+          f.puts unless unconfigured_nodes.empty?
+          unconfigured_nodes.each do |n|
+            log.info 'Adding %s to %s' % [ n['name'].inspect, ssh_config ]
+            f.puts "Host %s" % n['name']
+            f.puts "\tHostName\t%s" % n['name']
+            f.puts "\tPort\t22"
+            f.puts "\tUser\tvagrant"
+            f.puts "\tStrictHostKeyChecking\tno"
+            f.puts "\tIdentityFile\t~/.vagrant.d/insecure_private_key"
+            f.puts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bourdain/resources/checks.rb

@@ -0,0 +1,36 @@
+require 'erb'
+require 'fileutils'
+
+
+module Bourdain
+  module Checks
+    class Check < Bourdain::Resource
+    protected
+      def work_tree repo
+        "--work-tree=#{File.join(Dir.pwd, repo)}"
+      end
+
+      def git_dir repo
+        "--git-dir=#{File.join(Dir.pwd, repo, '.git')}"
+      end
+
+      def youre_behind? repo
+        `git #{git_dir repo} log ..origin/master --oneline`.split("\n").length > 0
+      end
+
+      def youre_ahead? repo
+        `git #{git_dir repo} log origin/master.. --oneline`.split("\n").length > 0
+      end
+
+      def youre_dirty? repo
+        `git #{git_dir repo} #{work_tree repo} diff HEAD --numstat`.split("\n").length > 0
+      end
+    end
+  end
+end
+
+require_relative 'checks/chef'
+require_relative 'checks/hooks'
+require_relative 'checks/bourdain'
+require_relative 'checks/cookbooks'
+require_relative 'checks/ssh_config'

data/lib/bourdain/resources/commands/bump.rb

@@ -0,0 +1,74 @@
+module Bourdain
+  module Commands
+
+    class BumpCommand < Command
+      usage :command, <<-END
+        Bump a VERSION file (patch by default)
+        bump [<options>] [<version-spec=major|minor|patch|x.y.z>]
+      END
+
+      def initialize argv
+        super
+        version_spec    = argv.shift
+        version_spec    = 'patch' if version_spec.nil?
+        verify! version_spec
+        return unless require_versionfile!
+        current_version = get_cookbook_version
+        new_version     = bump_version version_spec, current_version
+        set_cookbook_version new_version
+        log.info "Bumped to #{new_version}."
+      end
+
+
+    private
+      def set_cookbook_version version
+        File.open('VERSION', 'w') { |f| f.write version }
+      end
+
+      def get_cookbook_version
+        File.open('VERSION').read.strip
+      end
+
+      def verify! version_spec
+        case version_spec
+        when /major/
+          :major
+        when /minor/
+          :minor
+        when /patch/
+          :patch
+        when /\d+\.\d+\.\d+/
+          :manual
+        else
+          Trollop::die 'Invalid <version-spec> provided'
+        end
+      end
+
+      def bump_version version_spec, version
+        type = verify! version_spec
+
+        # I'm not really that thinky, so I stole this from knife-spork:
+        #
+        # https://github.com/jonlives/knife-spork/blob/master/lib/chef/knife/spork-bump.rb
+        #
+        if type == :manual
+          version_array = version_spec.split('.')
+
+        else
+          field = case type
+          when :patch ; 2
+          when :minor ; 1
+          when :major ; 0
+          end
+
+          version_array = version.split('.').map(&:to_i)
+          version_array[field] += 1
+          ((field + 1)..2).each { |i| version_array[i] = 0 }
+        end
+
+        version_array.join('.')
+      end
+    end
+
+  end
+end

data/lib/bourdain/resources/commands/check.rb

@@ -0,0 +1,103 @@
+require 'json'
+require 'fileutils'
+
+require 'pmap'
+require 'gitlab'
+
+
+module Bourdain
+  module Commands
+
+    class CheckCommand < Command
+      usage :command, <<-END
+        Check the state of the Kitchen, Bourdain and other things
+        check [<options>] [<check>]
+        <check>
+      END
+
+
+
+      def initialize argv
+        super
+        checks               = Bourdain::Registry.specs('check')
+        maybe_check_position = checks.map { |c| argv.index c[:name].to_s }.compact.shift
+        check_position       = maybe_check_position.nil? ? argv.length : maybe_check_position
+
+        options = argv.slice(0, check_position)
+        argv    = argv.slice(check_position, argv.length)
+
+        super options
+
+        begin
+          gitlab_token = Bourdain::Config.items[:gitlab][:token]
+        rescue
+          log.fatal "Couldn't find your GitLab token in your config, bailing!"
+          error!
+          return
+        end
+
+        Gitlab.configure do |gitlab|
+          gitlab.endpoint = "http://#{Bourdain::GITLAB_HOST}/api/v3"
+          gitlab.private_token = gitlab_token
+        end
+
+        check = argv.shift
+
+        unless check.nil?
+          check = Bourdain::Registry.klass('check', check)
+          Trollop::die 'Invalid <check> provided' if check.nil?
+        end
+
+        return unless require_chef!
+
+        if check.nil?
+          @status = Bourdain::Registry.map('check') do |c|
+            c.new(cookbook_config_from_gitlab).status
+          end.sort.last
+        else
+          @status = check.new(cookbook_config_from_gitlab).status
+        end
+      end
+
+
+
+    private
+      def cookbook_config_from_gitlab
+        cookbook_configs = []
+
+        # Have to page results as GitLab absolutely will not return more than
+        # 100 results per page (even if we ask for more)
+        1.upto(25) do |page|
+          Gitlab.projects(per_page: 50, page: page).each do |project|
+            namespace, name = project.name_with_namespace.split(' / ', 2)
+            namespace = nil if name.nil?
+            next unless namespace == 'chef'
+            next if %w[ chef kitchen bourdain ].include? name
+
+            cookbook_name = name.sub(/^\w+?_/, '')
+            cookbook_path = name.sub(/^(\w+?)_/, '\1s/bjn_')
+
+            # Fork names shouldn't have the bjn_ prefix
+            if name =~ /^fork_/
+              cookbook_name.sub!(/(bjn|fork)_/, '')
+              cookbook_path.sub!(/(bjn|fork)_/, '')
+            end
+
+            name =~ /^(\w+?)_/
+            cookbook_type = $1.to_sym
+
+            cookbook_configs << {
+              name: cookbook_name,
+              type: cookbook_type,
+              path: cookbook_path,
+              repo: "#{namespace}/#{name}.git",
+              project: project
+            }
+          end
+        end
+
+        cookbook_configs
+      end
+    end
+  end
+end

data/lib/bourdain/resources/commands/generate.rb

@@ -0,0 +1,33 @@
+module Bourdain
+  module Commands
+
+    class GenerateCommand < Command
+      usage :command, <<-END
+        Generate various things. Take that, Chef DK!
+        generate [<options>] <generator>
+        <generator>
+      END
+
+      def initialize argv
+        generators               = Bourdain::Registry.specs('generator')
+        maybe_generator_position = generators.map { |c| argv.index c[:name].to_s }.compact.shift
+        generator_position       = maybe_generator_position.nil? ? argv.length : maybe_generator_position
+        generator_name           = argv[generator_position]
+
+        options = argv.slice(0, generator_position)
+        argv    = argv.slice(generator_position, argv.length)
+
+        super options
+
+        generator = nil
+        generator = argv.shift unless maybe_generator_position.nil?
+        Trollop::die 'Invalid <generator> provided' if generator.nil?
+        generator = Bourdain::Registry.klass('generator', generator_name)
+        Trollop::die 'Invalid <generator> provided' if generator.nil?
+
+        @status = generator.new(argv).status
+      end
+    end
+
+  end
+end

data/lib/bourdain/resources/commands.rb

@@ -0,0 +1,10 @@
+module Bourdain
+  module Commands
+    class Command < Bourdain::Resource
+    end
+  end
+end
+
+require_relative 'commands/bump'
+require_relative 'commands/check'
+require_relative 'commands/generate'

data/lib/bourdain/resources/generators/attribute.rb

@@ -0,0 +1,43 @@
+module Bourdain
+  module Generators
+
+    class AttributeGenerator < Generator
+      usage :generator, <<-END
+        Generate a new attribute file in the current cookbook
+        attribute [<options>] <name>
+      END
+
+
+      def initialize argv
+        super
+
+        name = argv.shift
+        Trollop::die 'No <name> provided' if name.nil?
+        Trollop::die 'Invalid <name> provided' unless valid? name
+        name = normalized(name)
+
+        return unless require_cookbook!
+
+        FileUtils.mkdir_p 'attributes'
+        path = File.join('attributes', name + '.rb')
+
+        if File::exists? path
+          log.warn "Attribute file already exists. Doing nothing."
+          return
+        end
+
+        cookbook_name = File.basename Dir.pwd
+
+        apply_template path, \
+          template: %w[ cookbook attributes example.rb ],
+          locals: {
+            cookbook_name: cookbook_name,
+            name: name
+          }
+
+        log.info "Generated attribute file at #{path}"
+      end
+    end
+
+  end
+end

data/lib/bourdain/resources/generators/cookbook.rb

@@ -0,0 +1,125 @@
+require 'trollop'
+
+
+module Bourdain
+  module Generators
+
+    class CookbookGenerator < Generator
+      usage :generator, <<-END
+        Generate a new cookbook in the current repo
+        cookbook [<options>] <path>
+          --dot-chef (-c) :: Generate a .chef directory (default: false)
+          --git-init :: Initialize a git repository (default: true)
+          --attributes :: Generate a default attribute file (default: true)
+          --recipe :: Generate a default recipe (default: true)
+          --berksfile :: Generate a Berksfile (default: true)
+          --gitignore (-i) :: Generate a .gitignore (default: true)
+          --metadata :: Generate cookbook metadata (default: true)
+          --readme (-m) :: Generate a Readme (default: true)
+          --kitchenfile :: Generate a Test Kitchen file (default: true)
+          --vagrantfile :: Generate a Vagrantfile (default: true)
+          --versionfile (-z) :: Generate a VERSION file (default: true)
+          --pre-commit :: Generate a pre-commit hook (default: true)
+          --description (-p) <s> :: Description for resources
+      END
+
+      def initialize argv
+        super
+
+        path = argv.shift
+        Trollop::die 'No <path> provided' if path.nil?
+        Trollop::die 'Invalid <path> provided' unless valid? path
+
+        return unless require_chef!
+
+        if Dir::exists? path
+          log.warn "Cookbook already exists. Doing nothing."
+          return
+        end
+
+        name = File.basename(normalized(path))
+
+        FileUtils.mkdir_p path
+
+        if opts[:dot_chef]
+          FileUtils.mkdir_p File.join(path, '.chef/data_bags')
+          FileUtils.mkdir_p File.join(path, '.chef/nodes')
+        end
+
+        if opts[:attributes]
+          FileUtils.mkdir_p File.join(path, 'attributes')
+          apply_template File.join(path, 'attributes', 'default.rb'), \
+            template: %w[ cookbook attributes example.rb ], locals: {
+              name: 'default', cookbook_name: name
+            }
+        end
+
+        if opts[:recipe]
+          FileUtils.mkdir_p File.join(path, 'recipes')
+          apply_template File.join(path, 'recipes', 'default.rb'), \
+            template: %w[ cookbook recipes example.rb ], locals: {
+              name: 'default', cookbook_name: name
+            }
+        end
+
+        if opts[:berksfile]
+          apply_template File.join(path, 'Berksfile'), \
+            template: %w[ cookbook Berksfile ]
+        end
+
+        if opts[:gitignore]
+          apply_template File.join(path, '.gitignore'), \
+            template: %w[ cookbook gitignore ]
+        end
+
+        if opts[:metadata]
+          apply_template File.join(path, 'metadata.rb'), \
+            template: %w[ cookbook metadata.rb ], locals: { name: name }
+        end
+
+        if opts[:readme]
+          apply_template File.join(path, 'Readme.md'), \
+            template: %w[ cookbook Readme.md ], locals: { name: name }
+        end
+
+        if opts[:kitchenfile]
+          minitest_path = File.join(path, 'test', 'integration', 'default', 'minitest')
+          FileUtils.mkdir_p minitest_path
+          apply_template File.join(minitest_path, 'test_default.rb'), \
+            template: %w[ cookbook busser_minitest.rb ], locals: {
+              cookbook_name: name, recipe_name: 'default'
+            }
+          apply_template File.join(path, '.kitchen.yml'), \
+            template: %w[ cookbook kitchen.yml ], locals: { name: name }
+        end
+
+        if opts[:vagrantfile]
+          apply_template File.join(path, 'Vagrantfile'), \
+            template: %w[ cookbook Vagrantfile ], locals: { name: name }
+        end
+
+        if opts[:versionfile]
+          apply_template File.join(path, 'VERSION'), \
+            template: %w[ cookbook VERSION ]
+        end
+
+        if opts[:pre_commit]
+          hooks = File.join(path, '.git', 'hooks')
+          FileUtils.mkdir_p hooks
+          pre_commit_hook = File.join(hooks, 'pre-commit')
+          apply_template pre_commit_hook, template: %w[ cookbook pre-commit ]
+          FileUtils.chmod 0755, pre_commit_hook
+        end
+
+        if opts[:git_init]
+          Dir.chdir(path) do
+            `git init .`
+          end
+        end
+
+        log.info "Generated cookbook at #{path}."
+      end
+    end
+
+  end
+end

data/lib/bourdain/resources/generators/recipe.rb

@@ -0,0 +1,54 @@
+module Bourdain
+  module Generators
+
+    class RecipeGenerator < Generator
+      usage :generator, <<-END
+        Generate a new recipe in the current cookbook
+        recipe [<options>] <name>
+          --minitest :: Generate a minitest file (default: true)
+      END
+
+
+      def initialize argv
+        super
+
+        name = argv.shift
+        Trollop::die 'No <name> provided' if name.nil?
+        Trollop::die 'Invalid <name> provided' unless valid? name
+        name = normalized(name)
+
+        return unless require_cookbook!
+
+        FileUtils.mkdir_p 'recipes'
+        path = File.join('recipes', name + '.rb')
+
+        if File::exists? path
+          log.warn 'Recipe already exists. Doing nothing.'
+          return
+        end
+
+        cookbook_name = File.basename Dir.pwd
+
+        apply_template path, \
+          template: %w[ cookbook recipes example.rb ],
+          locals: {
+            cookbook_name: cookbook_name,
+            name: name
+          }
+
+        if opts[:minitest]
+          minitest_path = File.join('test', 'integration', 'default', 'minitest', "test_#{name}.rb")
+          FileUtils.mkdir_p File.dirname(minitest_path)
+          apply_template minitest_path, \
+            template: %w[ cookbook busser_minitest.rb ], locals: {
+              cookbook_name: cookbook_name, recipe_name: name
+            }
+          log.info "Generated test for recipe at #{minitest_path}."
+        end
+
+        log.info "Generated recipe at #{path}"
+      end
+    end
+
+  end
+end

data/lib/bourdain/resources/generators.rb

@@ -0,0 +1,22 @@
+require 'erb'
+require 'fileutils'
+
+
+module Bourdain
+  module Generators
+    class Generator < Bourdain::Resource
+    protected
+      def valid? name
+        name =~ /[_a-z]+/
+      end
+
+      def normalized name
+        File::basename(name, '.rb')
+      end
+    end
+  end
+end
+
+require_relative 'generators/attribute'
+require_relative 'generators/cookbook'
+require_relative 'generators/recipe'