kitchen-inspector 1.0.1 → 1.1.0

data/lib/kitchen-inspector/inspector/mixin/utils.rb

@@ -0,0 +1,83 @@
+#
+# 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
+    module Utils
+      def config_msg(human_name, field)
+        "#{human_name} not configured. Please set #{field} in your config file."
+      end
+
+      # Import a configuration from a file or StringIO
+      def read_config(config)
+        if config.is_a?(StringIO)
+          config.string
+        elsif File.exists?(config) && File.readable?(config)
+          IO.read(config)
+        else
+          raise ConfigurationError, "Unable to load the configuration: '#{config}'.\nPlease refer to README.md and check that a valid configuration was provided."
+        end
+      end
+
+      # Normalize version names to x.y.z...
+      def fix_version_name(version)
+        version.gsub(/[v][\.]*/i, "")
+      end
+
+      # Return from versions the best match that satisfies the given constraint
+      def satisfy(constraint, versions)
+        Solve::Solver.satisfy_best(constraint, versions).to_s
+      rescue Solve::Errors::NoSolutionError
+        nil
+      end
+
+      def get_latest_version(versions)
+        versions.collect do |v|
+          begin
+            Solve::Version.new(v)
+          rescue Solve::Errors::InvalidVersionFormat => e
+            # Skip invalid tags
+            Solve::Version.new("0.0.0")
+          end
+        end.max
+      end
+
+      # Evaluate only interesting lines
+      #
+      # Used also to ignore errors for missing
+      # files referenced in metadata.rb e.g., README.md
+      def eval_metadata(raw_response)
+        clean_response = raw_response.split("\n").select do |line|
+          line.strip!
+          line =~ /^depends|^name|^version/
+        end
+
+        metadata = Ridley::Chef::Cookbook::Metadata.new
+        metadata.instance_eval clean_response.join("\n")
+        metadata
+      end
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+#
+# 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 Report
+      class << self
+        # Generates the status of dependent cookbooks in specified format
+        def generate(dependencies, format, opts={})
+          case format
+          when 'table'
+            TableReport.generate(dependencies, opts)
+          when'json'
+            JSONReport.generate(dependencies)
+          else
+            raise UnsupportedReportFormatError, "Report format '#{format}' is not supported"
+          end
+        end
+      end
+    end
+
+    # Reports the cookbook dependency status in a table format
+    #
+    class TableReport
+      class << self
+        # Generate a report in tabular format
+        #
+        # @param dependencies [Array<Dependency>] list of cookbook dependency objects
+        # @param opts [Hash] options (only flag to show remarks at this stage)
+        # @return [Array] printable report and global status code
+        def generate(dependencies, opts)
+          headings = ["Name", "Requirement", "Used", "Chef\nLatest", "Repository\nLatest", "Requirement\nStatus",
+                      "Chef Server\nStatus", "Repository\nStatus"]
+
+          if opts[:remarks]
+            headings << "Remarks"
+            remarks_counter = 0
+            remarks = []
+          end
+
+          rows, remarks = generate_rows(dependencies, opts)
+
+          # Show Table
+          table = Terminal::Table.new headings: headings, rows: rows
+
+          # Show Status
+          g_status, g_status_code = StatusReporter.global_status(dependencies)
+
+          if opts[:remarks]
+            remarks_result = remarks.each_with_index.collect{|remark, idx| "[#{idx + 1}]: #{remark}"}.join("\n")
+            output = "#{table}\n#{g_status}\n\nRemarks:\n#{remarks_result}"
+          else
+            output = "#{table}\n#{g_status}"
+          end
+          [output, g_status_code]
+        end
+
+        # Generate table rows
+        def generate_rows(dependencies, opts)
+          rows = []
+          remarks = []
+
+          dependencies.select{|d| d.parents.empty?}.each do |dependency|
+            dep_rows, dep_remarks = display_child(dependency, remarks.size, 0, opts)
+
+            rows.push(*dep_rows)
+            remarks.push(*dep_remarks)
+          end
+          [rows, remarks]
+        end
+
+        def display_child(dependency, remarks_counter, level, opts)
+          row, remarks = generate_row(dependency, remarks_counter, level, opts)
+          remarks_counter += remarks.size
+          children_rows = []
+          children_remarks = []
+
+          dependency.dependencies.each do |child|
+            child_row, child_remarks = display_child(child, remarks_counter, level + 1, opts)
+            remarks_counter += child_remarks.size
+
+            children_rows.push(*child_row)
+            children_remarks.push(*child_remarks)
+          end
+
+
+          [[row, *children_rows], [remarks, children_remarks].flatten]
+        end
+
+        def indent_name(name, level)
+          level > 0 ? "#{(' ' * level) + INDENT_MARK} #{name}" : name
+        end
+
+        # Generate a single row and its remarks
+        def generate_row(dependency, remarks_counter, level, opts)
+          row_remarks = []
+
+          status = StatusReporter.status_to_mark(dependency.status)
+          chef_status = StatusReporter.status_to_mark(dependency.chef[:status])
+          repomanager_status = StatusReporter.status_to_mark(dependency.repomanager[:status])
+
+          name = indent_name(dependency.name.dup, level)
+          name = name.red if dependency.status == :err_req
+
+          row = [
+            name,
+            dependency.requirement,
+            dependency.chef[:version_used],
+            dependency.chef[:latest_version],
+            dependency.repomanager[:latest_metadata],
+            { value: status, alignment: :center },
+            { value: chef_status, alignment: :center },
+            { value: repomanager_status, alignment: :center }
+          ]
+
+          if opts[:remarks]
+            remarks_idx, remarks_counter = remarks_indices(dependency.remarks, remarks_counter)
+            row_remarks.push(*dependency.remarks)
+            row << remarks_idx
+          end
+
+          [row, row_remarks]
+        end
+
+        # Return the indices of the remarks
+        def remarks_indices(remarks, remarks_counter)
+          end_counter = remarks_counter + remarks.count
+
+          return [((remarks_counter + 1)..end_counter).to_a.join(', '), end_counter] unless remarks.empty?
+          return ['', end_counter]
+        end
+      end
+    end
+
+    # Return Kitchen's status in JSON format
+    class JSONReport
+      class << self
+        # @param dependencies [Array<Dependency>] list of dependencies
+        # @return [Array] JSON report and global status code
+        def generate(dependencies)
+          # Show Status
+          g_status, g_status_code = StatusReporter.global_status(dependencies)
+
+          [JSON.pretty_generate(dependencies_hash(dependencies)), g_status_code]
+        end
+
+        # Converts the dependency objects to JSON object
+        #
+        # @param dependencies [Array<Dependency>] list of dependencies
+        def dependencies_hash(dependencies)
+          {}.tap do |hash|
+            dependencies.each do |dependency|
+              hash[dependency.name] = dependency.to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitchen-inspector/inspector/report/status_reporter.rb

@@ -0,0 +1,105 @@
+#
+# 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
+    # Provides functions to report single or global status
+    class StatusReporter
+      class << self
+        # Return a global status
+        def global_status(dependencies)
+          result = nil
+          dependencies.each do |dep|
+            status = single_status(dep)
+
+            if status
+              result = status
+              break
+            end
+          end
+
+          unless result
+            result = {:mark => TICK_MARK, :color => :green, :code => :up_to_date}
+          end
+
+          ["Status: #{result[:code]} (#{result[:mark]})".send(result[:color]), result[:code]]
+        end
+
+        # Return a dependency local status if different from up-to-date
+        def single_status(dep)
+          return mark_structure(:err_req) if dep.status == :err_req
+
+          return mark_structure(:err_repo) if dep.repomanager[:status] == :err_repo
+
+          return mark_structure(:warn_outofdate_repo) if dep.repomanager[:status] == :warn_outofdate_repo
+
+          return mark_structure(:warn_req) if dep.status == :warn_req
+
+          return mark_structure(:warn_mismatch_repo) if dep.repomanager[:status] == :warn_mismatch_repo
+
+          return mark_structure(:warn_chef) if dep.chef[:status] == :warn_chef
+
+          return mark_structure(:warn_notunique_repo) if dep.repomanager[:status] == :warn_notunique_repo
+
+          nil
+        end
+
+        # Given a status return instructions on how to draw it
+        def mark_structure(status)
+          case status
+            when :err_req, :err_chef
+              {:mark => STATUSES[status], :color => :red, :code => status }
+            when :err_repo
+              {:mark => STATUSES[status], :color => :yellow, :code => status }
+            when :warn_outofdate_repo
+              {:mark => STATUSES[status], :color => :light_red, :code => status, :style => :bold }
+            when :warn_req
+              {:mark => STATUSES[status], :color => :yellow, :code => status, :style => :bold }
+            when :warn_mismatch_repo
+              {:mark => STATUSES[status], :color => :light_red, :code => status, :style => :bold }
+            when :warn_chef
+              {:mark => STATUSES[status], :color => :blue, :code => status, :style => :bold }
+            when :warn_notunique_repo
+              {:mark => STATUSES[status], :color => :light_red, :code => status }
+            when :up_to_date
+              {:mark => STATUSES[status], :color => :green, :code => status }
+            else
+              raise StandardError, "Unknown status #{status}"
+          end
+        end
+
+        # Given a status draw a mark
+        def status_to_mark(status)
+          mark = mark_structure(status)
+
+          result = mark[:mark]
+          result = result.send(mark[:style]) if mark[:style]
+          result = result.send(mark[:color])
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+#
+# 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 RepositoryInspector
+      include Utils
+
+      attr_accessor :manager
+
+      def initialize(config)
+        begin
+          require "kitchen-inspector/inspector/repository_managers/#{config[:type].downcase}"
+          manager_cls = "KitchenInspector::Inspector::#{config[:type]}Manager".constantize
+        rescue LoadError, NameError => e
+          raise RepositoryManagerError, "Repository Manager '#{config[:type]}' not supported"
+        end
+
+        @manager = manager_cls.new config
+      end
+
+      # Given a dependency and a version provided by Chef Server,
+      # analyze that dependency and its transitive dependencies (if recursive)
+      #
+      # It also detects whether multiple projects exist with the same name
+      # e.g., different users or forks
+      #
+      # @return [Array] containing pairs [dependency, repository_information]
+      def investigate(dependency, version_used, recursive)
+        repo_dependencies = []
+        projects = @manager.projects_by_name(dependency.name)
+
+        if projects.empty?
+          repo_dependencies << [dependency, {}]
+        else
+          projects.each do |project|
+            repo_info = analyze_repository(project)
+            repo_info[:not_unique] = projects.size > 1
+
+            # Inherit only shallow information from dependency
+            prj_dependency = Dependency.new(dependency.name, dependency.requirement)
+            prj_dependency.parents = dependency.parents
+
+            prj_dependency.parents.each do |parent|
+              parent.dependencies << prj_dependency
+            end
+
+            repo_dependencies << [prj_dependency, repo_info]
+
+            # Analyze its dependencies based on Repository Manager
+            if recursive && repo_info[:tags]
+              reference_version = get_reference_version(version_used, repo_info)
+
+              children = @manager.project_dependencies(project,
+                                    repo_info[:tags][reference_version]).collect do |dep|
+                dep.parents << prj_dependency
+                investigate(dep, version_used, recursive)
+              end.flatten!(1)
+
+              repo_dependencies.push(*children)
+            end
+          end
+        end
+
+        repo_dependencies
+      end
+
+      # Return the reference version to be used for recursive analysis
+      #
+      # It's the version used, if present. The latest available tag on the Repository
+      # Manager otherwise.
+      def get_reference_version(version_used, repo_info)
+        reference_version = nil
+        reference_version = version_used if version_used && repo_info[:tags].include?(version_used)
+        reference_version = repo_info[:latest_tag].to_s unless reference_version
+        reference_version
+      end
+
+      # Check whether tag and metadata's version match
+      def consistent_version?(info)
+        !(info[:latest_tag] &&
+          info[:latest_metadata] &&
+            info[:latest_tag] != info[:latest_metadata])
+      end
+
+      # Return an url pointing to the diff between startRev and endRev
+      def get_changelog(repo_info, startRev, endRev)
+        return unless repo_info[:tags]
+
+        url = @manager.changelog(repo_info[:source_url],
+                                               repo_info[:tags][startRev],
+                                               repo_info[:tags][endRev])
+        "Changelog: #{url}" if url
+      end
+
+      # Retrieve project info from Repository Manager
+      def analyze_repository(project)
+        tags = @manager.tags(project)
+        latest_tag = get_latest_version(tags.keys)
+
+        latest_metadata = @manager.project_metadata_version(project, tags[latest_tag.to_s])
+        latest_metadata = Solve::Version.new(latest_metadata) if latest_metadata
+
+        {:tags => tags,
+         :latest_tag => latest_tag,
+         :latest_metadata => latest_metadata,
+         :source_url => @manager.source_url(project)
+        }
+      end
+    end
+  end
+end