knife-inspect 0.6.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+!.gitkeep

data/Gemfile

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

data/HISTORY.md

@@ -0,0 +1,88 @@
+## 0.6.0 ( 2012-11-1 )
+
+* Add knife plugins for all existing functionality:
+  - knife inspect
+  - knife cookbook inspect [COOKBOOK]
+  - knife data bag inspect [BAG] [ITEM]
+  - knife environment inspect [ENVIRONMENT]
+  - knife role inspect [ROLE]
+
+* Lost support for quiet-sucess option (We can add that back, or make a quiet
+  options that just returns exit status).
+
+## 0.5.2 ( 2012-10-19 )
+
+* Make loading of Chef Config a little more robust.
+
+## 0.5.1 ( 2012-10-15 )
+
+* Ignore _default environment if it only exists on the server.
+
+## 0.5.0 ( 2012-10-14 )
+
+* Switch to RSpec
+* Add some test coverage (still needs much more).
+* Add option to suppress terminal output on successful checks.
+* Add option to not use ansi color output.
+* Make cookbook version comparison use Chef's native version class.
+
+## 0.4.1 ( 2012-09-28 )
+
+* Fix a bug I created in last release when passing no component.
+
+## 0.4.0 ( 2012-09-28 )
+
+* Make `inspect` the default task
+* Add ability to specify individual components:
+
+      health_inspector inspect cookbooks
+
+## 0.3.1 ( 2012-09-27 )
+
+* Stop shelling out for knife commands, use Chef API directly for everything.
+
+## 0.3.0 ( 2012-09-26 )
+
+* Add new check for cookbooks: checksum comparison for each file.
+
+## 0.2.1 ( 2012-09-26 )
+
+* Fix 1.8.7 incompatibility introduced in last release (String#prepend).
+
+## 0.2.0 ( 2012-09-25 )
+
+* Add a better diff output.
+* Add diff output to data bag items.
+* Switch to yajl-ruby to fix JSON parsing issues (Chef uses this also).
+
+## 0.1.0 ( 2012-09-24 )
+
+* Bump Chef dependency version up to 10.14
+* Add support for JSON environments.
+* Add support for JSON roles.
+* Display the diff between JSONs when JSON data doesn't match.
+
+## 0.0.6 ( 2012-05-23 )
+
+* Depend on Chef 0.10.8, since it depends on a later version of the json gem.
+  An earlier version of the json gem was throwing incorrect parse errors.
+
+## 0.0.5 ( 2012-04-13 )
+
+* Fix #2, exception when a data bag item json file doesn't exist locally.
+
+## 0.0.4 ( 2012-04-09 )
+
+* Add checks for data bags, data bag items, environments, and roles.
+
+## 0.0.3 ( 2012-03-27 )
+
+* Read cookbook paths from knife config file instead of hardcoding /cookbooks.
+
+## 0.0.2 ( 2012-03-27 )
+
+* Make sure we iterate over actual cookbooks in cookbooks folder.
+
+## 0.0.1 ( 2012-03-27 )
+
+* Initial release.

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Ben Marini
+
+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,43 @@
+[![Build Status](https://secure.travis-ci.org/bmarini/health_inspector.png)](http://travis-ci.org/bmarini/health_inspector)
+
+## Summary
+
+`health_inspector` is a knife plugin that inspects your chef repo as it
+compares to what is on your chef server. You can inspect your entire repo,
+or individual components.
+
+## Usage
+
+    $ gem install health_inspector
+    $ cd [chef repo]
+
+## Knife Commands
+
+    knife inspect
+
+    knife cookbook inspect
+    knife cookbook inspect [COOKBOOK]
+
+    knife data bag inspect
+    knife data bag inspect [BAG]
+    knife data bag inspect [BAG] [ITEM]
+
+    knife environment inspect
+    knife environment inspect [ENVIRONMENT]
+
+    knife role inspect
+    knife role inspect [ROLE]
+
+## What it does
+
+So far it checks if...
+
+* your cookbooks are in sync
+* you have uncommitted changes in a cookbook (assuming your cookbooks are in
+  their own git repos)
+* you have commits in a cookbook that haven't been pushed to your remote
+  (assuming your cookbooks are in their own git repos)
+* your data bags are in sync
+* your data bag items are in sync
+* your environments are in sync
+* your roles are in sync

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec

data/knife-inspect.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "health_inspector/version"
+
+Gem::Specification.new do |s|
+  s.name        = "knife-inspect"
+  s.version     = HealthInspector::VERSION
+  s.authors     = ["Ben Marini"]
+  s.email       = ["bmarini@gmail.com"]
+  s.homepage    = "https://github.com/bmarini/knife-inspect"
+  s.summary     = %q{Inspect your chef repo as is compares to what is on your chef server}
+  s.description = %q{Inspect your chef repo as is compares to what is on your chef server}
+
+  s.rubyforge_project = "knife-inspect"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+
+  s.add_runtime_dependency "thor"
+  s.add_runtime_dependency "chef", "~> 10.14"
+  s.add_runtime_dependency "yajl-ruby"
+end

data/lib/chef/knife/cookbook_inspect.rb

@@ -0,0 +1,36 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class CookbookInspect < Knife
+
+      deps do
+        require 'health_inspector'
+        require 'chef/json_compat'
+        require 'uri'
+        require 'chef/cookbook_version'
+      end
+
+      banner "knife cookbook inspect [COOKBOOK] (options)"
+
+      def run 
+        case @name_args.length
+        when 1 # We are inspecting a cookbook
+          cookbook_name = @name_args[0]
+          # TODO: Support environments
+          # env           = config[:environment]
+          # api_endpoint  = env ? "environments/#{env}/cookbooks/#{cookbook_name}" : "cookbooks/#{cookbook_name}"
+
+          validator = HealthInspector::Checklists::Cookbooks.new(self)
+          validator.validate_item( validator.load_item(cookbook_name) )
+        when 0 # We are inspecting all the cookbooks
+          HealthInspector::Checklists::Cookbooks.run(self)
+        end
+      end
+    end
+  end
+end
+
+
+
+

data/lib/chef/knife/data_bag_inspect.rb

@@ -0,0 +1,35 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class DataBagInspect < Knife
+
+      deps do
+        require 'health_inspector'
+      end
+
+      banner "knife data bag inspect [BAG] [ITEM] (options)"
+
+      def run
+        case @name_args.length
+        when 2 # We are inspecting a data bag item
+          bag_name  = @name_args[0]
+          item_name = @name_args[1]
+
+          validator = HealthInspector::Checklists::DataBagItems.new(self)
+          validator.validate_item( validator.load_item("#{bag_name}/#{item_name}") )
+
+        when 1 # We are inspecting a data bag
+          bag_name = @name_args[0]
+
+          validator = HealthInspector::Checklists::DataBags.new(self)
+          validator.validate_item( validator.load_item(bag_name) )
+
+        when 0 # We are inspecting all the data bags
+          HealthInspector::Checklists::DataBags.run(self)
+          HealthInspector::Checklists::DataBagItems.run(self)
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/environment_inspect.rb

@@ -0,0 +1,25 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class EnvironmentInspect < Knife
+
+      deps do
+        require 'health_inspector'
+      end
+
+      banner "knife environment inspect [ENVIRONMENT] (options)"
+
+      def run 
+        case @name_args.length
+        when 1 # We are inspecting a environment
+          environment_name = @name_args[0]
+          validator = HealthInspector::Checklists::Environments.new(self)
+          validator.validate_item( validator.load_item(environment_name) )
+        when 0 # We are inspecting all the environments
+          HealthInspector::Checklists::Environments.run(self)
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/inspect.rb

@@ -0,0 +1,20 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class Inspect < Knife
+
+      deps do
+        require "health_inspector"
+      end
+
+      banner "knife inspect"
+
+      def run
+        %w[ Cookbooks DataBags DataBagItems Environments Roles ].each do |checklist|
+          HealthInspector::Checklists.const_get(checklist).run(self)
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/role_inspect.rb

@@ -0,0 +1,25 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class RoleInspect < Knife
+
+      deps do
+        require 'health_inspector'
+      end
+
+      banner "knife role inspect [ROLE] (options)"
+
+      def run 
+        case @name_args.length
+        when 1 # We are inspecting a role
+          role_name = @name_args[0]
+          validator = HealthInspector::Checklists::Roles.new(self)
+          validator.validate_item( validator.load_item(role_name) )
+        when 0 # We are inspecting all the roles
+          HealthInspector::Checklists::Roles.run(self)
+        end
+      end
+    end
+  end
+end

data/lib/health_inspector.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+require "health_inspector/version"
+require "health_inspector/color"
+require "health_inspector/context"
+require "health_inspector/pairing"
+require "health_inspector/inspector"
+require "health_inspector/checklists/base"
+require "health_inspector/checklists/cookbooks"
+require "health_inspector/checklists/data_bags"
+require "health_inspector/checklists/data_bag_items"
+require "health_inspector/checklists/environments"
+require "health_inspector/checklists/roles"
+require 'chef/rest'
+require 'chef/checksum_cache'
+require 'chef/version'
+
+module HealthInspector
+end

data/lib/health_inspector/checklists/base.rb

@@ -0,0 +1,136 @@
+# encoding: UTF-8
+require "pathname"
+
+module HealthInspector
+  module Checklists
+    class Base
+      include Color
+
+      class << self
+        attr_reader :title
+
+        def title(val=nil)
+          val.nil? ? @title : @title = val
+        end
+      end
+
+      def self.run(knife)
+        new(knife).run
+      end
+
+      def initialize(knife)
+        @context = Context.new(knife)
+      end
+
+      def ui
+        @context.knife.ui
+      end
+
+      def all_item_names
+        ( server_items + local_items ).uniq.sort
+      end
+
+      # Subclasses should collect all items from the server and the local repo,
+      # and for each item pair, yield an object that contains a reference to
+      # the server item, and the local repo item. A reference can be nil if it does
+      # not exist in one of the locations.
+      def each_item
+        raise NotImplementedError, "You must implement this method in a subclass"
+      end
+
+      def run
+        banner "Inspecting #{self.class.title}"
+
+        each_item do |item|
+          validate_item(item)
+        end
+      end
+
+      def validate_item(item)
+        item.validate
+        failures = item.errors
+
+        if failures.empty?
+          print_success(item.name) # unless @context.quiet_success
+        else
+          print_failures(item.name, failures)
+        end
+      end
+
+      def banner(message)
+        ui.msg ""
+        ui.msg message
+        ui.msg "-" * 80
+      end
+
+      def print_success(subject)
+        ui.msg color('bright pass', "✓") + " #{subject}"
+      end
+
+      def print_failures(subject, failures)
+        ui.msg color('bright fail', "- #{subject}")
+
+        failures.each do |message|
+          if message.kind_of? Hash
+            puts color('bright yellow',"  has the following values mismatched on the server and repo\n")
+            print_failures_from_hash(message)
+          else
+            puts color('bright yellow', "  #{message}")
+          end
+        end
+      end
+
+      def print_failures_from_hash(message, depth=2)
+        message.keys.each do |key|
+          print_key(key,depth)
+
+          if message[key].include? "server"
+            print_value_diff(message[key],depth)
+            message[key].delete_if { |k,v| k == "server" || "local" }
+            print_failures_from_hash(message[key], depth + 1) unless message[key].empty?
+          else
+            print_failures_from_hash(message[key], depth + 1)
+          end
+        end
+      end
+
+      def print_key(key, depth)
+        ui.msg indent( color('bright yellow',"#{key} : "), depth )
+      end
+
+      def print_value_diff(value, depth)
+        print indent( color('bright fail',"server value = "), depth + 1 )
+        print value["server"]
+        print "\n"
+        print indent( color('bright fail',"local value  = "), depth + 1 )
+        print value["local"] 
+        print "\n\n"
+      end
+
+      def load_ruby_or_json_from_local(chef_class, folder, name)
+        path_template = "#{@context.repo_path}/#{folder}/#{name}.%s"
+        ruby_pathname = Pathname.new(path_template % "rb")
+        json_pathname = Pathname.new(path_template % "json")
+        js_pathname   = Pathname.new(path_template % "js")
+
+        if ruby_pathname.exist?
+          instance = chef_class.new
+          instance.from_file(ruby_pathname.to_s)
+        elsif json_pathname.exist?
+          instance = chef_class.json_create( Yajl::Parser.parse( json_pathname.read ) )
+        elsif js_pathname.exist?
+          instance = chef_class.json_create( Yajl::Parser.parse( js_pathname.read ) )
+        end
+
+        instance ? instance.to_hash : nil
+      rescue IOError
+        nil
+      end
+
+      def indent(string, depth)
+        (' ' * 2 * depth) + string
+      end
+
+    end
+  end
+end

data/lib/health_inspector/checklists/cookbooks.rb

@@ -0,0 +1,134 @@
+module HealthInspector
+  module Checklists
+
+    class Cookbook < Pairing
+      include ExistenceValidations
+
+      def validate_versions
+        if versions_exist? && !versions_match?
+          errors.add "chef server has #{server} but local version is #{local}"
+        end
+      end
+
+      def validate_uncommited_changes
+        if git_repo?
+          result = `cd #{cookbook_path} && git status -s`
+
+          unless result.empty?
+            errors.add "Uncommitted changes:\n#{result.chomp}"
+          end
+        end
+      end
+
+      def validate_commits_not_pushed_to_remote
+        if git_repo?
+          result = `cd #{cookbook_path} && git status`
+
+          if result =~ /Your branch is ahead of (.+)/
+            errors.add "ahead of #{$1}"
+          end
+        end
+      end
+
+      # TODO: Check files that exist locally but not in manifest on server
+      def validate_changes_on_the_server_not_in_the_repo
+        if versions_exist? && versions_match?
+
+          begin
+            cookbook = context.rest.get_rest("/cookbooks/#{name}/#{local}")
+            messages = []
+
+            Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+              cookbook.manifest[segment].each do |manifest_record|
+                path = cookbook_path.join("#{manifest_record["path"]}")
+
+                if path.exist?
+                  checksum = checksum_cookbook_file(path)
+                  messages << "#{manifest_record['path']}" if checksum != manifest_record['checksum']
+                else
+                  messages << "#{manifest_record['path']} does not exist in the repo"
+                end
+              end
+            end
+
+            unless messages.empty?
+              message = "has a checksum mismatch between server and repo in\n"
+              message << messages.map { |f| "    #{f}" }.join("\n")
+              errors.add message
+            end
+
+          rescue Net::HTTPServerException => e
+            errors.add "Could not find cookbook #{name} on the server"
+          end
+
+        end
+      end
+
+      def versions_exist?
+        local && server
+      end
+
+      def versions_match?
+        local == server
+      end
+
+      def git_repo?
+        cookbook_path && File.exist?("#{cookbook_path}/.git")
+      end
+
+      def cookbook_path
+        path = context.cookbook_path.find { |f| File.exist?("#{f}/#{name}") }
+        path ? Pathname.new(path).join(name) : nil
+      end
+
+      def checksum_cookbook_file(filepath)
+        Chef::CookbookVersion.checksum_cookbook_file(filepath)
+      end
+
+    end
+
+    class Cookbooks < Base
+
+      title "cookbooks"
+
+      def each_item
+        all_cookbook_names = ( server_cookbooks.keys + local_cookbooks.keys ).uniq.sort
+
+        all_cookbook_names.each do |name|
+          yield load_item(name)
+        end
+      end
+
+      def load_item(name)
+        Cookbook.new(@context,
+          :name   => name,
+          :server => server_cookbooks[name],
+          :local  => local_cookbooks[name]
+        )
+      end
+
+      def server_cookbooks
+        @context.rest.get_rest("/cookbooks").inject({}) do |hsh, (name,version)|
+          hsh[name] = Chef::Version.new(version["versions"].first["version"])
+          hsh
+        end
+      end
+
+      def local_cookbooks
+        @context.cookbook_path.
+          map { |path| Dir["#{path}/*"] }.
+          flatten.
+          select { |path| File.exists?("#{path}/metadata.rb") }.
+          inject({}) do |hsh, path|
+
+            name    = File.basename(path)
+            version = (`grep '^version' #{path}/metadata.rb`).split.last[1...-1]
+
+            hsh[name] = Chef::Version.new(version)
+            hsh
+          end
+      end
+
+    end
+  end
+end

data/lib/health_inspector/checklists/data_bag_items.rb

@@ -0,0 +1,60 @@
+require "chef/data_bag"
+
+module HealthInspector
+  module Checklists
+    class DataBagItem < Pairing
+      include ExistenceValidations
+      include JsonValidations
+    end
+
+    class DataBagItems < Base
+      title "data bag items"
+
+      def each_item
+        all_item_names.each do |name|
+          yield load_item(name)
+        end
+      end
+
+      def load_item(name)
+        DataBagItem.new(@context,
+          :name   => name,
+          :server => load_item_from_server(name),
+          :local  => load_item_from_local(name)
+        )
+      end
+
+      def server_items
+        @server_items ||= Chef::DataBag.list.keys.map do |bag_name|
+          [ bag_name, Chef::DataBag.load(bag_name) ]
+        end.inject([]) do |arr, (bag_name, data_bag)|
+          arr += data_bag.keys.map { |item_name| "#{bag_name}/#{item_name}"}
+        end
+      end
+
+      def local_items
+        entries = nil
+
+        Dir.chdir("#{@context.repo_path}/data_bags") do
+          entries = Dir["**/*.json"].map { |entry| entry.gsub('.json', '') }
+        end
+
+        return entries
+      end
+
+      def load_item_from_server(name)
+        bag_name, item_name = name.split("/")
+        Chef::DataBagItem.load(bag_name, item_name).raw_data
+      rescue
+        nil
+      end
+
+      def load_item_from_local(name)
+        Yajl::Parser.parse( File.read("#{@context.repo_path}/data_bags/#{name}.json") )
+      rescue IOError, Errno::ENOENT
+        nil
+      end
+    end
+
+  end
+end

data/lib/health_inspector/checklists/data_bags.rb

@@ -0,0 +1,38 @@
+require "chef/data_bag"
+
+module HealthInspector
+  module Checklists
+    class DataBag < Pairing
+      include ExistenceValidations
+    end
+
+    class DataBags < Base
+      title "data bags"
+
+      def each_item
+        all_item_names.each do |name|
+          yield load_item(name)
+        end
+      end
+
+      def load_item(name)
+        DataBag.new(@context,
+          :name   => name,
+          :server => server_items.include?(name),
+          :local  => local_items.include?(name)
+        )
+      end
+
+      def server_items
+        @server_items ||= Chef::DataBag.list.keys
+      end
+
+      def local_items
+        @local_items ||= Dir["#{@context.repo_path}/data_bags/*"].entries.
+          select { |e| File.directory?(e) }.
+          map { |e| File.basename(e) }
+      end
+    end
+
+  end
+end

data/lib/health_inspector/checklists/environments.rb

@@ -0,0 +1,55 @@
+require "chef/environment"
+
+module HealthInspector
+  module Checklists
+    class Environment < Pairing
+      include ExistenceValidations
+      include JsonValidations
+
+      # Override to ignore _default environment if it is missing locally
+      def validate_local_copy_exists
+        super unless name == '_default'
+      end
+    end
+
+    class Environments < Base
+      title "environments"
+
+      def each_item
+        all_item_names.each do |name|
+          yield load_item(name)
+        end
+      end
+
+      def load_item(name)
+        Environment.new(@context,
+          :name   => name,
+          :server => load_item_from_server(name),
+          :local  => load_item_from_local(name)
+        )
+      end
+
+      def server_items
+        @server_items ||= Chef::Environment.list.keys
+      end
+
+      def local_items
+        Dir.chdir("#{@context.repo_path}/environments") do
+          Dir["*.{rb,json,js}"].map { |e| e.gsub(/\.(rb|json|js)/,"") }
+        end
+      end
+
+      def load_item_from_server(name)
+        env = Chef::Environment.load(name)
+        env.to_hash
+      rescue
+        nil
+      end
+
+      def load_item_from_local(name)
+        load_ruby_or_json_from_local(Chef::Environment, "environments", name)
+      end
+    end
+
+  end
+end

data/lib/health_inspector/checklists/roles.rb

@@ -0,0 +1,51 @@
+require "chef/role"
+require 'yajl'
+
+module HealthInspector
+  module Checklists
+    class Role < Pairing
+      include ExistenceValidations
+      include JsonValidations
+    end
+
+    class Roles < Base
+      title "roles"
+
+      def each_item
+        all_item_names.each do |name|
+          yield load_item(name)
+        end
+      end
+
+      def load_item(name)
+        Role.new(@context,
+          :name   => name,
+          :server => load_item_from_server(name),
+          :local  => load_item_from_local(name)
+        )
+      end
+
+      def server_items
+        @server_items ||= Chef::Role.list.keys
+      end
+
+      def local_items
+        Dir.chdir("#{@context.repo_path}/roles") do
+          Dir["*.{rb,json,js}"].map { |e| e.gsub(/\.(rb|json|js)/, '') }
+        end
+      end
+
+      def load_item_from_server(name)
+        role = Chef::Role.load(name)
+        role.to_hash
+      rescue
+        nil
+      end
+
+      def load_item_from_local(name)
+        load_ruby_or_json_from_local(Chef::Role, "roles", name)
+      end
+    end
+
+  end
+end

data/lib/health_inspector/color.rb

@@ -0,0 +1,31 @@
+module HealthInspector
+  module Color
+
+    # TODO: Use a highline color scheme here instead
+    def color(type, str)
+      colors = {
+        'pass'          => [:green],# 90,
+        'fail'          => [:red],# 31,
+        'bright pass'   => [:bold, :green],# 92,
+        'bright fail'   => [:bold, :red],# 91,
+        'bright yellow' => [:bold, :yellow],# 93,
+        'pending'       => [:yellow],# 36,
+        'suite'         => [],# 0,
+        'error title'   => [],# 0,
+        'error message' => [:red],# 31,
+        'error stack'   => [:green],# 90,
+        'checkmark'     => [:green],# 32,
+        'fast'          => [:green],# 90,
+        'medium'        => [:green],# 33,
+        'slow'          => [:red],# 31,
+        'green'         => [:green],# 32,
+        'light'         => [:green],# 90,
+        'diff gutter'   => [:green],# 90,
+        'diff added'    => [:green],# 42,
+        'diff removed'  => [:red]# 41
+      }
+
+      @context.knife.ui.color( str, *colors[type] )
+    end
+  end
+end

data/lib/health_inspector/context.rb

@@ -0,0 +1,27 @@
+require "chef/config"
+
+module HealthInspector
+  class Context
+    attr_accessor :knife
+
+    def initialize(knife)
+      @knife = knife
+    end
+
+    def cookbook_path
+      Array( config.cookbook_path )
+    end
+
+    def config
+      Chef::Config
+    end
+
+    def rest
+      @knife.rest
+    end
+
+    def repo_path
+      ENV['PWD']
+    end
+  end
+end

data/lib/health_inspector/inspector.rb

@@ -0,0 +1,20 @@
+module HealthInspector
+  class Inspector
+    def self.inspect(checklists, options)
+      new(options).inspect( checklists )
+    end
+
+    def initialize(options)
+      @context = Context.new( options[:repopath], options[:configpath] )
+      @context.quiet_success = options[:'quiet-success']
+      @context.no_color      = options[:'no-color']
+      @context.configure
+    end
+
+    def inspect(checklists)
+      checklists.each do |checklist|
+        Checklists.const_get(checklist).run(@context) if Checklists.const_defined?(checklist)
+      end
+    end
+  end
+end

data/lib/health_inspector/pairing.rb

@@ -0,0 +1,73 @@
+module HealthInspector
+  class Errors
+    include Enumerable
+
+    def initialize
+      @errors = []
+    end
+
+    def add(message)
+      @errors << message
+    end
+
+    def each
+      @errors.each { |e| yield(e) }
+    end
+
+    def empty?
+      @errors.empty?
+    end
+  end
+
+  class Pairing
+    attr_accessor :name, :local, :server
+    attr_reader :context, :errors
+
+    def initialize(context, opts={})
+      @context     = context
+      @name        = opts[:name]
+      @local       = opts[:local]
+      @server      = opts[:server]
+
+      @validations = []
+      @errors      = Errors.new
+    end
+
+    def validate
+      self.methods.grep(/^validate_/).each { |meth| send(meth) }
+    end
+
+    def hash_diff(original, other)
+      (original.keys + other.keys).uniq.inject({}) do |memo, key|
+        unless original[key] == other[key]
+          if original[key].kind_of?(Hash) && other[key].kind_of?(Hash)
+            memo[key] = hash_diff(original[key], other[key])
+          else
+            memo[key] = {"server" => original[key],"local" => other[key]}
+          end
+        end
+        memo
+      end
+    end
+  end
+
+  # Mixins for common validations across pairings
+  module ExistenceValidations
+    def validate_local_copy_exists
+      errors.add "exists on server but not locally" if local.nil?
+    end
+
+    def validate_server_copy_exists
+      errors.add "exists locally but not on server" if server.nil?
+    end
+  end
+
+  module JsonValidations
+    def validate_items_are_the_same
+      if server && local
+        differences = hash_diff(server, local)
+        errors.add differences unless differences.empty?
+      end
+    end
+  end
+end

data/lib/health_inspector/version.rb

@@ -0,0 +1,3 @@
+module HealthInspector
+  VERSION = "0.6.0"
+end

data/spec/chef-repo/.chef/knife.rb

@@ -0,0 +1,7 @@
+chef_repo_dir = File.expand_path( "../", File.dirname(__FILE__) )
+
+client_key               "#{chef_repo_dir}/.chef/client.pem"
+log_level                :info
+log_location             STDOUT
+cache_type               "BasicFile"
+cookbook_path            [ "#{chef_repo_dir}/cookbooks" ]

data/spec/cookbook_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe HealthInspector::Checklists::Cookbook do
+  let(:pairing) { described_class.new(health_inspector_context, :name => "dummy") }
+
+  it "should detect if an item does not exist locally" do
+    pairing.server = "0.0.1"
+    pairing.local  = nil
+    pairing.validate
+
+    pairing.errors.should_not be_empty
+    pairing.errors.first.should == "exists on server but not locally"
+  end
+
+  it "should detect if an item does not exist on server" do
+    pairing.server = nil
+    pairing.local  = "0.0.1"
+    pairing.validate
+
+    pairing.errors.should_not be_empty
+    pairing.errors.first.should == "exists locally but not on server"
+  end
+
+  it "should detect if an item is different" do
+    pairing.server = "0.0.1"
+    pairing.local  = "0.0.2"
+    pairing.validate
+
+    pairing.errors.should_not be_empty
+    pairing.errors.first.should == "chef server has 0.0.1 but local version is 0.0.2"
+  end
+
+  it "should detect if an item is the same" do
+    pairing.should_receive(:validate_changes_on_the_server_not_in_the_repo)
+    pairing.server = "0.0.1"
+    pairing.local  = "0.0.1"
+    pairing.validate
+
+    pairing.errors.should be_empty
+  end
+end

data/spec/data_bag_item_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe HealthInspector::Checklists::DataBagItem do
+  it_behaves_like "a chef model"
+  it_behaves_like "a chef model that can be respresented in json"
+end

data/spec/data_bag_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe HealthInspector::Checklists::DataBag do
+  it_behaves_like "a chef model"
+end

data/spec/environment_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe HealthInspector::Checklists::Environment do
+  let(:pairing) { described_class.new(health_inspector_context) }
+
+  it_behaves_like "a chef model"
+  it_behaves_like "a chef model that can be respresented in json"
+
+  it "should ignore _default environment if it only exists on server" do
+    pairing.name   = "_default"
+    pairing.server = {}
+    pairing.local  = nil
+    pairing.validate
+
+    pairing.errors.should be_empty
+  end
+
+end

data/spec/role_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe HealthInspector::Checklists::Role do
+  it_behaves_like "a chef model"
+  it_behaves_like "a chef model that can be respresented in json"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'health_inspector'
+
+module HealthInspector::SpecHelpers
+  def health_inspector_context
+    @health_inspector_context ||= HealthInspector::Context.new(nil)
+  end
+end
+
+RSpec.configure do |c|
+  c.include HealthInspector::SpecHelpers
+end
+
+shared_examples "a chef model" do
+  let(:pairing) { described_class.new(health_inspector_context, :name => "dummy") }
+
+  it "should detect if an item does not exist locally" do
+    pairing.server = {}
+    pairing.local  = nil
+    pairing.validate
+
+    pairing.errors.should_not be_empty
+    pairing.errors.first.should == "exists on server but not locally"
+  end
+
+  it "should detect if an item does not exist on server" do
+    pairing.server = nil
+    pairing.local  = {}
+    pairing.validate
+
+    pairing.errors.should_not be_empty
+    pairing.errors.first.should == "exists locally but not on server"
+  end
+end
+
+shared_examples "a chef model that can be respresented in json" do
+  let(:pairing) { described_class.new(health_inspector_context, :name => "dummy") }
+
+  it "should detect if an item is different" do
+    pairing.server = {"foo" => "bar"}
+    pairing.local  = {"foo" => "baz"}
+    pairing.validate
+
+    pairing.errors.should_not be_empty
+    pairing.errors.first.should == {"foo"=>{"server"=>"bar", "local"=>"baz"}}
+  end
+
+  it "should detect if an item is the same" do
+    pairing.server = {"foo" => "bar"}
+    pairing.local  = {"foo" => "bar"}
+    pairing.validate
+
+    pairing.errors.should be_empty
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: knife-inspect
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+  prerelease: 
+platform: ruby
+authors:
+- Ben Marini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70274490577920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70274490577920
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70274490573900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70274490573900
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70274490581800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70274490581800
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: &70274490608360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70274490608360
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70274490625560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70274490625560
+description: Inspect your chef repo as is compares to what is on your chef server
+email:
+- bmarini@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- HISTORY.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- knife-inspect.gemspec
+- lib/chef/knife/cookbook_inspect.rb
+- lib/chef/knife/data_bag_inspect.rb
+- lib/chef/knife/environment_inspect.rb
+- lib/chef/knife/inspect.rb
+- lib/chef/knife/role_inspect.rb
+- lib/health_inspector.rb
+- lib/health_inspector/checklists/base.rb
+- lib/health_inspector/checklists/cookbooks.rb
+- lib/health_inspector/checklists/data_bag_items.rb
+- lib/health_inspector/checklists/data_bags.rb
+- lib/health_inspector/checklists/environments.rb
+- lib/health_inspector/checklists/roles.rb
+- lib/health_inspector/color.rb
+- lib/health_inspector/context.rb
+- lib/health_inspector/inspector.rb
+- lib/health_inspector/pairing.rb
+- lib/health_inspector/version.rb
+- spec/chef-repo/.chef/client.pem
+- spec/chef-repo/.chef/knife.rb
+- spec/cookbook_spec.rb
+- spec/data_bag_item_spec.rb
+- spec/data_bag_spec.rb
+- spec/environment_spec.rb
+- spec/role_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bmarini/knife-inspect
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: knife-inspect
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Inspect your chef repo as is compares to what is on your chef server
+test_files:
+- spec/chef-repo/.chef/client.pem
+- spec/chef-repo/.chef/knife.rb
+- spec/cookbook_spec.rb
+- spec/data_bag_item_spec.rb
+- spec/data_bag_spec.rb
+- spec/environment_spec.rb
+- spec/role_spec.rb
+- spec/spec_helper.rb