kitchen-inspector 1.0.1 → 1.1.0

data/kitchen-inspector.gemspec

@@ -3,12 +3,24 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'kitchen-inspector/inspector/version'
 
+# Generate pre-release versions for non tagged releases
+git_version = begin
+  describe = `git describe`
+  if $?.success?
+    stripped = describe.strip
+    /^([^-]+)-([0-9]+)-[^-]+$/.match(stripped) ? "#{$1}.#{$2}" : stripped
+  else
+    git_raw = `git log --pretty=format:%h | head -n1`
+    $?.success? ? '0.0.0.%d' % git_raw.strip.to_i(16) : '0.0.0'
+  end
+end
+
 Gem::Specification.new do |spec|
   spec.name          = "kitchen-inspector"
-  spec.version       = KitchenInspector::Inspector::VERSION
+  spec.version       = git_version
   spec.authors       = ["Stefano Tortarolo"]
   spec.email         = ["stefano.tortarolo@gmail.com"]
-  spec.description   = %q{Given an Opscode Chef cookbook, verifies its dependencies against a Chef Server and a Gitlab instance}
+  spec.description   = %q{Given a Chef cookbook, verifies its dependencies against a Chef Server and a Repository Manager instance (i.e., GitHub/GitLab)}
   spec.summary       = %q{Kitchen integrity checker}
   spec.homepage      = "https://github.com/astratto/kitchen-inspector"
   spec.license       = "MIT"
@@ -21,12 +33,18 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rubocop", "~> 0.14"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency 'chef-zero'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency "gitlab", "~> 3.0"
+  spec.add_development_dependency "octokit", "~> 2.6"
 
   spec.add_dependency "solve", "~> 0.8.0"
   spec.add_dependency "berkshelf", "~> 2.0.10"
   spec.add_dependency "thor", "~> 0.18.0"
   spec.add_dependency "terminal-table", "~> 1.4.5"
   spec.add_dependency "colorize", "~> 0.6.0"
-  spec.add_dependency "gitlab"
+  spec.add_dependency "httparty", "~> 0.10.0"
+  spec.add_dependency "googl", "~> 0.6.3"
   spec.add_dependency "chef", ">= 11.0.0"
 end

data/lib/kitchen-inspector/inspector.rb

@@ -29,11 +29,18 @@ require 'colorize'
 require 'ridley'
 require 'terminal-table'
 require 'thor'
-require 'gitlab'
+require 'googl'
 
+require 'kitchen-inspector/inspector/common'
+require 'kitchen-inspector/inspector/mixin/utils'
 require 'kitchen-inspector/inspector/cli'
-require 'kitchen-inspector/inspector/error'
 require 'kitchen-inspector/inspector/dependency'
-require 'kitchen-inspector/inspector/dependency_inspector'
-require 'kitchen-inspector/inspector/report'
+
+require 'kitchen-inspector/inspector/chef_inspector'
+require 'kitchen-inspector/inspector/repository_inspector'
+require 'kitchen-inspector/inspector/health_bureau'
+
+require 'kitchen-inspector/inspector/repository_managers/base'
+require 'kitchen-inspector/inspector/report/report'
+require 'kitchen-inspector/inspector/report/status_reporter'
 require 'kitchen-inspector/inspector/version'

data/lib/kitchen-inspector/inspector/chef_inspector.rb

@@ -0,0 +1,66 @@
+#
+# Copyright (c) 2013 Stefano Tortarolo <stefano.tortarolo@gmail.com>
+#
+# MIT License
+#
+# 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.
+#
+
+module KitchenInspector
+  module Inspector
+    class ChefInspector
+      include Utils
+
+      def initialize(config)
+        @chef_server_url = config[:url]
+        @chef_username = config[:username]
+        @chef_client_pem = config[:client_pem]
+
+        raise ChefAccessNotConfiguredError, config_msg("Chef Server url", ":url") unless @chef_server_url
+        raise ChefAccessNotConfiguredError, config_msg("Chef username", ":username") unless @chef_username
+        raise ChefAccessNotConfiguredError, config_msg("Chef client PEM", ":client_pem") unless @chef_client_pem
+
+        @chef_info_cache = {}
+      end
+
+      def investigate(dependency)
+        cache_key = "#{dependency.name}, #{dependency.requirement}"
+        @chef_info_cache[cache_key] ||= begin
+          chef_info = {}
+          chef_info[:versions] = find_versions(dependency.name)
+          chef_info[:latest_version] = get_latest_version(chef_info[:versions])
+          chef_info[:version_used] = satisfy(dependency.requirement, chef_info[:versions])
+          chef_info
+        end
+      end
+
+      # Given a project return the versions on the Chef Server
+      def find_versions(project)
+        rest = Chef::REST.new(@chef_server_url, @chef_username, @chef_client_pem)
+        cookbook = rest.get("cookbooks/#{project}")
+        versions = []
+        versions = cookbook[project]["versions"].collect{|c| fix_version_name(c["version"])} if cookbook
+        versions
+      rescue Net::HTTPServerException
+        []
+      end
+    end
+  end
+end

data/lib/kitchen-inspector/inspector/cli.rb

@@ -34,20 +34,46 @@ module KitchenInspector
                              default: 'table',
                              aliases: '-t'
 
-      desc 'investigate (COOKBOOK_PATH)', 'Check Gitlab/Chef status of dependent cookbooks'
+      method_option :recursive, type: :boolean,
+                             desc: 'Specify whether recursive dependencies must be analyzed',
+                             default: true,
+                             aliases: '-r'
+
+      method_option :config, type: :string,
+                             desc: 'The configuration to use',
+                             default: File.join("#{Dir.home}", ".chef", "kitchen_inspector.rb"),
+                             aliases: '-c'
+
+      method_option :remarks, type: :boolean,
+                             desc: 'Show remarks (useful to provide more descriptive information)',
+                             default: false,
+                             aliases: '--remarks'
+
+      desc 'investigate (COOKBOOK_PATH)', 'Check Repository Manager/Chef Server status of dependent cookbooks'
 
       map 'inspect'   => :investigate
       def investigate(path=Dir.pwd)
-        dependencies = DependencyInspector.investigate path
+        inspector = HealthBureau.new options[:config]
+
+        dependencies = inspector.investigate(path, options[:recursive])
+
         if dependencies.empty?
           puts 'No dependent cookbooks'.yellow
+          status_code = :'warning-nodependencies'
         else
-          puts Report.generate(dependencies, options[:format])
+          output, status_code = Report.generate(dependencies, options[:format], options)
+          puts output
         end
+        exit STATUS_TO_RETURN_CODES[status_code]
+      rescue ConfigurationError => e
+        puts e.message.red
+        exit STATUS_TO_RETURN_CODES[:'error-config']
       rescue NotACookbookError
         puts 'The path is not a cookbook path'.red
+        exit STATUS_TO_RETURN_CODES[:'error-notacookbook']
       rescue UnsupportedReportFormatError
         puts "The report format #{options[:format]} is not supported".red
+        exit STATUS_TO_RETURN_CODES[:'error-reportformat']
       end
     end
   end

data/lib/kitchen-inspector/inspector/{error.rb → common.rb}

@@ -25,10 +25,52 @@
 
 module KitchenInspector
   module Inspector
-    class GitlabAccessNotConfiguredError < StandardError; end
+    class ConfigurationError < StandardError; end
+    class RepositoryManagerError < ConfigurationError; end
+
     class ChefAccessNotConfiguredError < StandardError; end
     class NotACookbookError < StandardError; end
     class DuplicateCookbookError < StandardError; end
     class UnsupportedReportFormatError < ArgumentError; end
+
+    # Graphical marks
+    TICK_MARK = "\u2714"
+    X_MARK = "\u2716"
+    ESCLAMATION_MARK = "!"
+    INFO_MARK = "i"
+    INDENT_MARK = "\u203A"
+    QUESTION_MARK = "?"
+
+    # Dependency statuses
+    STATUSES = {
+      :up_to_date => TICK_MARK,
+      :err_req => X_MARK,
+      :err_repo => X_MARK,
+      :err_chef => X_MARK,
+      :warn_req => ESCLAMATION_MARK,
+      :warn_chef => INFO_MARK,
+      :warn_mismatch_repo => ESCLAMATION_MARK,
+      :warn_outofdate_repo => (ESCLAMATION_MARK * 2),
+      :warn_notunique_repo => QUESTION_MARK
+    }
+    STATUSES.default = ' '
+
+    # Possible return codes
+    #
+    # Note that global :err_chef is not possible since there would
+    # be at least one :err_req that takes precedence
+    STATUS_TO_RETURN_CODES = {
+      :up_to_date => 0,
+      :err_req => 100,
+      :err_repo => 101,
+      :err_config => 102,
+      :err_notacookbook => 103,
+      :err_reportformat => 104,
+      :warn_req => 200,
+      :warn_mismatch_repo => 201,
+      :warn_outofdate_repo => 202,
+      :warn_chef => 203
+    }
+    STATUS_TO_RETURN_CODES.default = 1
   end
 end

data/lib/kitchen-inspector/inspector/dependency.rb

@@ -27,73 +27,59 @@ module KitchenInspector
   module Inspector
     # The class that contains information about a dependent cookbook
     class Dependency
+      include Comparable
+
       # The name of the dependency
       attr_reader :name
 
       # The requirement for the dependency
       attr_reader :requirement
 
-      # The version of cookbook used after applying the version constraint
-      attr_accessor :version_used
-
-      # The versions available on Chef Server
-      attr_accessor :chef_versions
-
-      # The latest version available on Chef Server
-      attr_accessor :latest_chef
+      # Info from Chef Server
+      attr_accessor :chef
 
-      # The versions available on Gitlab
-      attr_accessor :gitlab_versions
-
-      # The latest version available on Gitlab
-      attr_accessor :latest_gitlab
+      # Info from the Repository Manager
+      attr_accessor :repomanager
 
       # The status of the dependency
       attr_accessor :status
 
-      # The status of Gitlab
-      attr_accessor :gitlab_status
-
-      # The status of Chef Server
-      attr_accessor :chef_status
-
-      # The source URL for a cookbook
-      attr_accessor :source_url
-
-      # The changelog link for the dependency if available
-      attr_accessor :changelog
+      # The dependencies of a cookbook
+      attr_accessor :dependencies
 
       # Remarks field
       attr_accessor :remarks
 
+      # Dependency's parents (if transitive)
+      attr_accessor :parents
+
       def initialize(name, requirement)
         @name = name
         @requirement = requirement
-        @version_used = nil
-        @chef_versions = []
-        @latest_chef = nil
-        @gitlab_versions = []
-        @latest_gitlab = nil
+        @chef = {}
+        @repomanager = {}
         @status = nil
-        @gitlab_status = nil
-        @chef_status = nil
-        @source_url = nil
         @remarks = []
+        @dependencies = []
+        @parents = []
+      end
+
+      def ==(anOther)
+        name == anOther.name && requirement == anOther.requirement
       end
 
       def to_hash
         {}.tap do |hash|
+          hash[:name] = name
           hash[:requirement] = requirement
-          hash[:used] = version_used
-          hash[:chef_versions] = chef_versions
-          hash[:latest_chef] = latest_chef
-          hash[:gitlab_versions] = gitlab_versions
-          hash[:latest_gitlab] = latest_gitlab
           hash[:status] = status
-          hash[:gitlab_status] = gitlab_status
-          hash[:chef_status] = chef_status
-          hash[:source_url] = source_url
           hash[:remarks] = remarks
+          hash[:dependencies] = dependencies
+          hash[:chef] = chef
+          hash[:chef][:latest_version] = hash[:chef][:latest_version].to_s if hash[:chef][:latest_version]
+          hash[:repomanager] = repomanager
+          hash[:repomanager][:latest_tag] = hash[:repomanager][:latest_tag].to_s if hash[:repomanager][:latest_tag]
+          hash[:repomanager][:latest_metadata] = hash[:repomanager][:latest_metadata].to_s if hash[:repomanager][:latest_metadata]
         end
       end
     end

data/lib/kitchen-inspector/inspector/health_bureau.rb

@@ -0,0 +1,181 @@
+#
+# Copyright (c) 2013 Stefano Tortarolo <stefano.tortarolo@gmail.com>
+#
+# MIT License
+#
+# 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.
+#
+
+module KitchenInspector
+  module Inspector
+    # Main class that, starting from a cookbook, analyzes its dependencies
+    # using its "inspectors" and returns a collection of analyzed dependencies
+    class HealthBureau
+      include Utils
+
+      attr_reader :chef_inspector, :repo_inspector
+
+      def initialize(config)
+        configuration = read_config(config)
+
+        begin
+          self.instance_eval configuration
+        rescue NoMethodError => e
+          raise ConfigurationError, "Unsupported configuration: #{e.name}"
+        end
+      end
+
+      # Inspect your kitchen!
+      #
+      # If recursive is specified, dependencies' metadata are downloaded and recursively analyzed
+      #
+      # @param path [String] path to the cookbook to be analyzed
+      # @param recursive [Boolean] whether transitive dependencies should be analyzed
+      # @return [Array<Dependency>] analyzed dependency and its transitive dependencies
+      def investigate(path, recursive=true)
+        raise NotACookbookError, 'Path is not a cookbook' unless File.exists?(File.join(path, 'metadata.rb'))
+
+        metadata = Ridley::Chef::Cookbook::Metadata.from_file(File.join(path, 'metadata.rb'))
+        metadata.dependencies.collect do |name, version|
+          analyze_dependency(Dependency.new(name, version), recursive)
+        end.flatten
+      end
+
+      # Analyze Chef repo and Repository manager in order to find more information
+      # about a given dependency
+      #
+      # @param dependency [Dependency] dependency to be analyzed
+      # @param recursive [Boolean] whether transitive dependencies should be analyzed
+      # @return [Array<Dependency>] analyzed dependency and its transitive dependencies
+      def analyze_dependency(dependency, recursive)
+        chef_info = @chef_inspector.investigate(dependency)
+
+        # Grab information from the Repository Manager
+        info_repo = @repo_inspector.investigate(dependency, chef_info[:version_used], recursive)
+        deps = info_repo.collect do |dep, repo_info|
+          dep_chef_info = @chef_inspector.investigate(dep)
+          update_dependency(dep, dep_chef_info, repo_info)
+          dep
+        end
+        deps
+      end
+
+      # Update in-place a dependency based on information retrieved from
+      # Chef Server and Repository Manager
+      #
+      # @param dependency [Dependency] dependency to be updated
+      # @param chef_info [Hash] information from Chef Server
+      # @param repo_info [Hash] information from Repository Manager
+      def update_dependency(dependency, chef_info, repo_info)
+        dependency.status = :up_to_date
+
+        if !chef_info[:version_used]
+          dependency.status = :err_req
+          msg = 'No versions found'
+          reference_version = @repo_inspector.get_reference_version(nil, repo_info)
+          msg << ", using #{reference_version} for recursive analysis" if reference_version
+
+          dependency.remarks << msg
+        else
+          relaxed_version = satisfy("~> #{chef_info[:version_used]}", chef_info[:versions])
+          if relaxed_version != chef_info[:version_used]
+            dependency.status = :warn_req
+            changelog_url = @repo_inspector.get_changelog(repo_info,
+                                          chef_info[:version_used],
+                                          relaxed_version)
+            dependency.remarks << "#{relaxed_version} is available. #{changelog_url}"
+          end
+        end
+
+        # Compare Chef and Repository Manager versions
+        comparison = compare_repo_chef(chef_info, repo_info)
+        chef_info[:status] = comparison[:chef]
+        repo_info[:status] = comparison[:repo]
+        dependency.remarks.push(*comparison[:remarks]) if comparison[:remarks]
+
+        if repo_info[:not_unique]
+          repo_info[:status] = :warn_notunique_repo
+          dependency.remarks << "Not unique on #{@repo_inspector.manager.type} (this is #{repo_info[:source_url]})"
+        end
+
+        # Check whether latest tag and metadata version in Repository Manager are
+        # consistent
+        unless @repo_inspector.consistent_version?(repo_info)
+          repo_info[:status] = :warn_mismatch_repo
+          dependency.remarks << "#{@repo_inspector.manager.type}'s last tag is #{repo_info[:latest_tag]} " \
+                                  "but found #{repo_info[:latest_metadata]} in metadata.rb"
+        end
+
+        dependency.repomanager = repo_info
+        dependency.chef = chef_info
+      end
+
+      # Compare Repository Manager and Chef Server
+      #
+      # @param chef_info [Hash] information from Chef Server
+      # @param repo_info [Hash] information from Repository Manager
+      # @return [Hash] containing servers statuses and remarks
+      def compare_repo_chef(chef_info, repo_info)
+        comparison = {:chef => :up_to_date, :repo => :up_to_date,
+                  :remarks => []}
+
+        if chef_info[:latest_version] && repo_info[:latest_metadata]
+          if chef_info[:latest_version] > repo_info[:latest_metadata]
+            comparison[:repo] = :warn_outofdate_repo
+            changelog_url = @repo_inspector.get_changelog(repo_info,
+                                          repo_info[:latest_metadata].to_s,
+                                          chef_info[:latest_version].to_s)
+            comparison[:remarks] << "#{@repo_inspector.manager.type} out-of-date! #{changelog_url}"
+            return comparison
+          elsif chef_info[:latest_version] < repo_info[:latest_metadata]
+            comparison[:chef] = :warn_chef
+            changelog_url = @repo_inspector.get_changelog(repo_info,
+                                          chef_info[:latest_version].to_s,
+                                          repo_info[:latest_metadata].to_s)
+            comparison[:remarks] << "A new version might appear on Chef server. #{changelog_url}"
+            return comparison
+          end
+        end
+
+        unless repo_info[:latest_metadata]
+          comparison[:repo] = :err_repo
+          comparison[:remarks] << "#{@repo_inspector.manager.type} doesn't contain any versions."
+        end
+
+        unless chef_info[:latest_version]
+          comparison[:chef] = :err_chef
+          comparison[:remarks] << "Chef Server doesn't contain any versions."
+        end
+
+        comparison
+      end
+
+      # Initialize the Chef Server configuration
+      def chef_server(config)
+        @chef_inspector = ChefInspector.new config
+      end
+
+      # Initialize the Repository Manager
+      def repository_manager(config)
+        @repo_inspector = RepositoryInspector.new config
+      end
+    end
+  end
+end