knife-depsolver 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5937e944afd44c612b2fe9beb72ab82fc54b6fb
-  data.tar.gz: 6d29b51bacad2ecc548abde5836745976cfcdfbe
+  metadata.gz: 6778025284948e0f288edf8c6c7f2c2524b183a4
+  data.tar.gz: 0ede42f4cc18050f8e27c28b96b454aa62e3c4a8
 SHA512:
-  metadata.gz: c6458795f49739bceb38884ba4fe2d534a3f07c7bb005adf981e833230b27813d9391dd21e1259b3b1c20e9621ebfb093b28e40115bed8d7d208ddc8027296c8
-  data.tar.gz: 3c27e32e8bba168011d2afd4407fcdf552e92035f146a0108a31c3b9f4127701e9dec02c2a6150ca22831a4e3e35775b44ad58e9e28aade5e6786e478839853c
+  metadata.gz: ed6a0cf93519256d488c6038f8aaf7c93647cd6620025b05cd95ba3cdb41b0b8194d012989a61c55ec1ecc208d4dd6d8adaa69619097e52748334dc2260924a0
+  data.tar.gz: 6d754f00136a1174ceefcd1f5c47025d4113b420e169eb9405786425de8fb308a7d0a99241677b8c261d452c52542b93cb02d5b5161f27187cb30efeec1ca58d

data/CHANGELOG.md

@@ -1,9 +1,18 @@
-# Change Log
-
-## 1.0.1
-
-Add error handling
-
-## 1.0.0
-
-Initial release
+# Change Log
+
+## 2.0.0 (2017-05-02)
+
+* Set the node's environment to ensure accurate run_list expansion
+* Add --capture option to capture all relevant information for local depsolver usage
+* Add ability to use Chef DK's local depsolver to make calculations identical to a Chef Server
+* Add --timeout option
+* Add --csv-universe-to-json option for converting SQL captured cookbook universe to JSON
+* Add --env-constraints-filter-universe option
+
+## 1.0.1 (2016-03-17)
+
+* Add error handling
+
+## 1.0.0 (2016-03-17)
+
+* Initial release

data/README.md

@@ -1,38 +1,146 @@
-## knife-depsolver
-
-Knife plugin that uses Chef Server to calculate cookbook dependencies for a given run_list.
-
-### Install
-
-```
-chef gem install knife-depsolver
-```
-
-### Usage
-
-Find the depsolver solution for an arbitrary run_list.
-Specifying recipes and even cookbook version constraints is allowed.
-
-```
-knife depsolver 'cookbook-B,cookbook-A::foo@3.1.4,cookbook-R'
-```
-
-Find the depsolver solution for an arbitrary run_list using a specific environment's cookbook version constraints.
-Specifying recipes and even cookbook version constraints is allowed.
-
-```
-knife depsolver -E production 'cookbook-B,cookbook-A::foo@3.1.4,cookbook-R'
-```
-
-Find the depsolver solution for a node's run_list.
-
-```
-knife depsolver -n demo-node
-```
-
-Find the depsolver solution for a node's run_list using a specific environment's cookbook version constraints.
-
-```
-knife depsolver -E production -n demo-node
-```
-
+## knife-depsolver
+
+Knife plugin that calculates Chef cookbook dependencies for a given run_list.
+
+Some features of knife-depsolver:
+
+1. Able to capture all relevant information and use Chef DK's embedded depsolver.
+2. JSON output for easy parsing
+3. API error handling provides very helpful information
+4. Accepts cookbook version constraints directly in the run_list
+5. Useful information such as environment cookbook version constraints, expanded run_list and elapsed time for depsolver request
+6. Ordering of depsolver results is maintained rather than sorted so you see what really gets passed to the chef-client
+
+### How Does Cookbook Dependency Solving Work?
+
+During a chef-client run the chef-client expands the node's run_list which means the chef-client recursively expands
+any existing role run_lists until the expanded run_list only consists of a list of cookbook recipes.
+
+Then chef-client sends the expanded run_list to the Chef Server's `/organizations/ORGNAME/environments/ENVNAME/cookbook_versions`
+API endpoint which is serviced by opscode-erchef.
+
+opscode-erchef gets the ORGNAME organization's cookbook universe (cookbook dependency info for every version of every cookbook)
+and the ENVNAME environment's cookbook version constraints from the database.
+
+opscode-erchef sends the expanded run_list, environment constraints and cookbook universe to a ruby process running the
+[depselector.rb script](https://github.com/chef/chef-server/blob/12.9.1/src/oc_erchef/apps/chef_objects/priv/depselector_rb/depselector.rb).
+
+This script uses the [dep_selector gem](https://github.com/chef/dep-selector) to build a dependency graph that filters out any
+cookbook versions that don't satisfy the environment cookbook version constraints.
+
+The dep_selector gem re-formulates the dependency graph and the solution constraints as a CSP and off-loads the hard work to
+[Gecode](http://www.gecode.org/), a fast, license-friendly solver written in C++. If Gecode returns a solution then that is used by
+opscode-erchef to send a list of cookbook file metadata back to the chef-client so it can synchronize its cookbook cache.
+
+### Install
+
+```
+chef gem install knife-depsolver
+```
+
+### Using knife-depsolver with Chef Server's depsolver
+
+Find the depsolver solution for a node's run_list.
+
+```
+knife depsolver -n demo-node
+```
+
+Find the depsolver solution for an arbitrary run_list.
+Specifying roles, recipes and even cookbook version constraints is allowed.
+
+```
+knife depsolver 'role[base],cookbook-B,cookbook-A::foo@3.1.4,cookbook-R'
+```
+
+The "-E <environment>" option can be added to use a specific environment's cookbook version constraints.
+
+```
+knife depsolver -E production -n demo-node
+OR
+knife depsolver -E production 'role[base],cookbook-B,cookbook-A::foo@3.1.4,cookbook-R'
+```
+
+### Using knife-depsolver with Chef DK's embedded depsolver
+
+It can be difficult to identify the source of the problem if we hit a depsolver issue in the Chef Server.
+
+knife-depsolver can provide many more troubleshooting options by using the depsolver embedded in your workstation's Chef DK to make an identical calculation as the Chef Server.
+
+First, you need to make sure that your version of Chef DK is using the same version of the dep_selector gem as your version of Chef Server. If your Chef DK is using a different version of the dep_selector gem then knife-depsolver's calculations will not be identical to the Chef Server's calculations which will confuse troubleshooting efforts.
+
+| dep_selector gem | Chef Server | Chef DK    |
+| ---------------- | ----------- | ---------- |
+| 1.0.3            | <= 12.8.0   | <= 0.16.28 |
+| 1.0.4            | >= 12.9.0   | >= 0.17.17 |
+
+Once you are sure you are using the correct version of Chef DK and you have installed the knife-depsolver plugin you can use the "--capture" option which queries the Chef Server and creates a separate file on the workstation for each of the following pieces of information.
+
+1. environment cookbook version constraints
+2. cookbook universe
+3. expanded run list
+
+The name of each file includes a creation timestamp and a SHA-1 checksum of the contents of the file. These can help during the troubleshooting process to make sure we know when the capture was done and whether anyone has modified the contents of the file.
+
+For example:
+
+```
+knife depsolver -E production -n demo-node --capture
+OR
+knife depsolver -E production 'role[base],cookbook-B,cookbook-A::foo@3.1.4,cookbook-R' --capture
+```
+
+Now use the "--env-constraints", "universe" and "expanded-run-list" options to provide all the information required for local depsolver calculations.
+
+For example:
+
+```
+knife depsolver --env-constraints rehearsal-environment-20170501185240-5f5843d819ecb0b174f308d76d4336bb7bbfacbf.txt --universe automate-universe-20170501185240-1c8e59e23530b1e1a8e0b3b3cc5236a29c84e469.txt --expanded-run-list expanded-run-list-20170501185240-387d90499514747792a805213c30be13d830d31f.txt
+```
+
+Now it is easy to modify any combination of the expanded run list, the environment cookbook version constraints or the cookbook universe in those files and see the impact on the depsolver in an effort to isolate the problem.
+
+Sometimes it can help to give the depsolver more than the default five seconds to perform its calculations. This can be done by using the "--timeout <seconds>" option to change the depsolver timeout.
+
+```
+knife depsolver --env-constraints production-environment-20170501185240-5f5843d819ecb0b174f308d76d4336bb7bbfacbf.txt --universe my-org-universe-20170501185240-1c8e59e23530b1e1a8e0b3b3cc5236a29c84e469.txt --expanded-run-list expanded-run-list-20170501185240-387d90499514747792a805213c30be13d830d31f.txt --timeout 120
+```
+
+### Chef Server <= 12.4.0
+
+knife-depsolver requires cookbook universe data in order to use Chef DK's embedded depsolver. The "/universe" API endpoint was added in the Chef Server 12.4.0 release.
+
+If you are using a version of Chef Server older than 12.4.0 then you can run the following command on your Chef Server to extract the cookbook universe directly from the database in CSV format.
+
+```
+export ORGNAME=demo
+
+cat <<EOF | chef-server-ctl psql opscode_chef --options '-tAF,' > universe.csv
+SELECT cvd.name,
+cvd.major || '.' || cvd.minor || '.' || cvd.patch AS version,
+updated_at,
+dependencies
+FROM cookbook_version_dependencies cvd
+INNER JOIN cookbooks ckbks
+ON cvd.org_id = ckbks.org_id
+AND cvd.name = ckbks.name
+INNER JOIN cookbook_versions cv
+ON ckbks.id = cv.cookbook_id
+AND cvd.major = cv.major
+AND cvd.minor = cv.minor
+AND cvd.patch = cv.patch
+WHERE cvd.org_id = (SELECT id
+FROM orgs
+WHERE name = '$ORGNAME'
+LIMIT 1)
+ORDER BY updated_at DESC;
+EOF
+```
+
+Then you can run "knife depsolver --csv-universe-to-json universe.csv" to convert it to the normal JSON format.
+
+If the Chef Server doesn't have the "chef-server-ctl psql" command available then you can try replacing that line with the following.
+
+```
+cat <<EOF | su -l opscode-pgsql -c 'psql opscode_chef -tAF,' > universe.csv
+```

data/lib/chef/knife/depselector.rb

@@ -0,0 +1,138 @@
+# I pulled and slightly modified this script from
+# https://github.com/chef/dep-selector/blob/master/scripts/depselector.rb
+# which was originally pulled and slightly modified from
+# https://github.com/chef/chef-server/blob/12.9.0/src/oc_erchef/apps/chef_objects/priv/depselector_rb/depselector.rb
+
+# Test script to take a dependency graph in JSON format and solve it
+# ensure that the Gemfile is in the cwd
+# Dir.chdir(File.dirname(__FILE__))
+
+# require 'json'
+# require 'pp'
+require 'dep_selector'
+# require 'pry'
+
+def translate_constraint(constraint)
+  case constraint
+  when Symbol
+    case constraint
+    when :gt then ">"
+    when :gte then ">="
+    when :lt then "<"
+    when :lte then "<="
+    when :eq then "="
+    when :pes then "~>"
+    else constraint.to_s
+    end
+  when NilClass
+    "="
+  else
+    constraint
+  end
+end
+
+def constraint_to_str(constraint, constraint_version)
+  return nil unless constraint_version
+  "#{translate_constraint(constraint)} #{constraint_version}"
+end
+
+def solve(data)
+    begin
+      # create dependency graph from cookbooks
+      graph = DepSelector::DependencyGraph.new
+
+      env_constraints = data[:environment_constraints].inject({}) do |acc, env_constraint|
+        name, version, constraint = env_constraint
+        acc[name] = DepSelector::VersionConstraint.new(constraint_to_str(constraint, version))
+        acc
+      end
+
+      all_versions = []
+
+      data[:all_versions].each do | vsn|
+        name, version_constraints = vsn
+        version_constraints.each do |version_constraint| # todo: constraints become an array in ruby
+                                                         # due to the erlectricity conversion from
+                                                         # tuples
+          version, constraints = version_constraint
+
+          # filter versions based on environment constraints
+          env_constraint = env_constraints[name]
+          if (!env_constraint || env_constraint.include?(DepSelector::Version.new(version)))
+            package_version = graph.package(name).add_version(DepSelector::Version.new(version))
+            constraints.each do |package_constraint|
+              constraint_name, constraint_version, constraint = package_constraint
+              version_constraint = DepSelector::VersionConstraint.new(constraint_to_str(constraint, constraint_version))
+              dependency = DepSelector::Dependency.new(graph.package(constraint_name), version_constraint)
+              package_version.dependencies << dependency
+            end
+          end
+        end
+
+        # regardless of filter, add package reference to all_packages
+        all_versions << graph.package(name)
+      end
+
+      run_list = data[:run_list].map do |run_list_item|
+        item_name, item_constraint_version, item_constraint = run_list_item
+        version_constraint = DepSelector::VersionConstraint.new(constraint_to_str(item_constraint,
+                                                                                  item_constraint_version))
+        DepSelector::SolutionConstraint.new(graph.package(item_name), version_constraint)
+      end
+
+      timeout_ms = data[:timeout_ms]
+      selector = DepSelector::Selector.new(graph, (timeout_ms / 1000.0))
+
+      answer = begin
+                 solution = selector.find_solution(run_list, all_versions)
+                 packages = []
+                 solution.each do |package, v|
+                   packages << [package, [v.major, v.minor, v.patch]]
+                 end
+                 [:ok, packages]
+               rescue DepSelector::Exceptions::InvalidSolutionConstraints => e
+                 non_existent_cookbooks = e.non_existent_packages.inject([]) do |list, constraint|
+                   list << constraint.package.name
+                 end
+
+                 constrained_to_no_versions = e.constrained_to_no_versions.inject([]) do |list, constraint|
+                   list << constraint.to_s
+                 end
+
+                 error_detail = [[:non_existent_cookbooks, non_existent_cookbooks],
+                                 [:constraints_not_met, constrained_to_no_versions]]
+
+                 [:error, :invalid_constraints, error_detail]
+               rescue DepSelector::Exceptions::NoSolutionExists => e
+                 most_constrained_cookbooks = e.disabled_most_constrained_packages.inject([]) do |list, package|
+                   # WTF: this is the reported error format but I can't find this anywhere in the ruby code
+                   list << "#{package.name} = #{package.versions.first.to_s}"
+                 end
+
+                 non_existent_cookbooks = e.disabled_non_existent_packages.inject([]) do |list, package|
+                   list << package.name
+                 end
+
+                 error_detail = [[:message, e.message],
+                                               [:unsatisfiable_run_list_item, e.unsatisfiable_solution_constraint.to_s],
+                                               [:non_existent_cookbooks, non_existent_cookbooks],
+                                               [:most_constrained_cookbooks, most_constrained_cookbooks]]
+
+                 [:error, :no_solution, error_detail]
+               rescue DepSelector::Exceptions::TimeBoundExceeded,
+                      DepSelector::Exceptions::TimeBoundExceededNoSolution => e
+                 # While dep_selector differentiates between the two solutions, the opscode-chef
+                 # API returns the same error regardless of the timeout type. We'll swallow the
+                 # difference here and return a unified timeout to erchef
+                 [:error, :resolution_timeout]
+               end
+    rescue => e
+      answer = [:error, :exception, e.message, [e.backtrace]]
+    end
+
+    answer
+end
+
+# data = JSON.parse!(File.read(ARGV[0]), symbolize_names: true)
+# pp data
+# pp solve(data)

data/lib/chef/knife/depsolver.rb

@@ -1,77 +1,322 @@
-require 'chef/knife'
-
-class Chef
-  class Knife
-    class Depsolver < Knife
-      deps do
-      end
-
-      banner 'knife depsolver RUN_LIST'
-
-      option :node,
-             short: '-n',
-             long: '--node NAME',
-             description: 'Use the run list from a given node'
-
-      def run
-        begin
-          if config[:node]
-            node = Chef::Node.load(config[:node])
-          else
-            node = Chef::Node.new
-            node.name('depsolver-tmp-node')
-
-            run_list = name_args.map {|item| item.to_s.split(/,/) }.flatten.each{|item| item.strip! }
-            run_list.delete_if {|item| item.empty? }
-
-            run_list.each do |arg|
-              node.run_list.add(arg)
-            end
-          end
-
-          environment = config[:environment]
-          environment ||= node.chef_environment
-
-          environment_cookbook_versions = Chef::Environment.load(environment).cookbook_versions
-
-          run_list_expansion = node.expand!
-          expanded_run_list_with_versions = run_list_expansion.recipes.with_version_constraints_strings
-
-          depsolver_start_time = Time.now
-
-          ckbks = rest.post_rest("environments/" + environment + "/cookbook_versions", { "run_list" => expanded_run_list_with_versions })
-
-          depsolver_finish_time = Time.now
-
-          depsolver_results = {}
-          ckbks.each do |name, ckbk|
-            version = ckbk.is_a?(Hash) ? ckbk['version'] : ckbk.version
-            depsolver_results[name] = version
-          end
-
-        rescue => e
-          api_error = {}
-          api_error[:error_code] = e.response.code
-          api_error[:error_message] = e.response.message
-          begin
-            api_error[:error_body] = JSON.parse(e.response.body)
-          rescue JSON::ParserError
-          end
-        ensure
-          results = {}
-          results[:node] = node.name unless node.nil? || node.name.nil?
-          results[:environment] = environment unless environment.nil?
-          results[:environment_cookbook_versions] = environment_cookbook_versions unless environment_cookbook_versions.nil?
-          results[:run_list] = node.run_list unless node.nil? || node.run_list.nil?
-          results[:expanded_run_list] = expanded_run_list_with_versions unless expanded_run_list_with_versions.nil?
-          results[:depsolver_results] = depsolver_results unless depsolver_results.nil? || depsolver_results.empty?
-          results[:depsolver_cookbook_count] = ckbks.count unless ckbks.nil?
-          results[:depsolver_elapsed_ms] = ((depsolver_finish_time - depsolver_start_time) * 1000).to_i unless depsolver_finish_time.nil?
-          results[:api_error] = api_error unless api_error.nil?
-
-          msg(JSON.pretty_generate(results))
-        end
-      end
-    end
-  end
-end
+require 'chef/knife'
+require 'digest'
+
+class Chef
+  class Knife
+    class Depsolver < Knife
+      deps do
+      end
+
+      banner 'knife depsolver RUN_LIST'
+
+      option :node,
+             short: '-n',
+             long: '--node NAME',
+             description: 'Use the run list from a given node'
+
+      option :timeout,
+             short: '-t',
+             long: '--timeout SECONDS',
+             description: 'Set the local depsolver timeout. Only valid when using the --env-constraints and --universe options'
+
+      option :capture,
+             long: '--capture',
+             description: 'Save the expanded run list, environment cookbook constraints and cookbook universe to files for local depsolving'
+
+      option :env_constraints,
+             long: '--env-constraints FILENAME',
+             description: 'Use the environment cookbook constraints from FILENAME. REQUIRED when using the local depsolver.'
+
+      option :universe,
+             long: '--universe FILENAME',
+             description: 'Use the cookbook universe from FILENAME. REQUIRED when using the local depsolver.'
+
+       option :expanded_run_list,
+              long: '--expanded-run-list FILENAME',
+              description: 'Use the expanded run list from FILENAME. REQUIRED when using the local depsolver.'
+
+      option :csv_universe_to_json,
+             long: '--csv-universe-to-json FILENAME',
+             description: 'Convert a CSV cookbook universe, FILENAME, to JSON.'
+
+      option :env_constraints_filter_universe,
+           long: '--env-constraints-filter-universe',
+           description: 'Filter the cookbook universe using the environment cookbook version constraints.'
+
+      def run
+        begin
+          use_local_depsolver = false
+          if config[:env_constraints_filter_universe]
+            if config[:node] || config[:environment] || config[:timeout] || config[:capture] || config[:expanded_run_list] || config[:csv_universe_to_json]
+              msg("ERROR: The --env-constraints-filter-universe option is only compatible with the --env-constraints and --universe options")
+              exit!
+            elsif !(config[:env_constraints] && config[:universe])
+              msg("ERROR: The --env-constraints-filter-universe option requires the --env-constraints and --universe options to be set")
+              exit!
+            end
+          else
+            if config[:env_constraints] || config[:universe] || config[:expanded_run_list]
+              if config[:env_constraints] && config[:universe] && config[:expanded_run_list]
+                use_local_depsolver = true
+                unless name_args.empty?
+                  puts "ERROR: Setting a run list on the command line is not compatible with the --env-constraints, --universe or --expanded-run-list options"
+                  exit!
+                end
+                if config[:node]
+                  puts "ERROR: The --node option is not compatible with the --env-constraints, --universe or --expanded-run-list options"
+                  exit!
+                end
+                if config[:environment]
+                  puts "ERROR: The --environment option is not compatible with the --env-constraints, --universe or --expanded-run-list options"
+                  exit!
+                end
+                if config[:capture]
+                  puts "ERROR: The --capture option is not compatible with the --env-constraints, --universe or --expanded-run-list options"
+                  exit!
+                end
+              else
+                puts "ERROR: The --env-constraints, --universe and --expanded-run-list options must be used together to use the local depsolver"
+                exit!
+              end
+            end
+          end
+          if config[:timeout] && !use_local_depsolver
+            msg("ERROR: The --timeout option requires the --env-constraints, --universe and --expanded-run-list options to be set")
+            exit!
+          end
+
+          timeout = (config[:timeout].to_f * 1000).to_i if config[:timeout]
+          timeout ||= 5 * 1000
+
+          if config[:csv_universe_to_json]
+            unless File.file?(config[:csv_universe_to_json])
+              msg("ERROR: #{config[:csv_universe_to_json]} does not exist or is not a file.")
+              exit!
+            end
+            universe = Hash.new { |hash, key| hash[key] = Hash.new }
+            IO.foreach(config[:csv_universe_to_json]) do |line|
+              name, version, updated_at, dependencies = line.split(",", 4)
+              universe[name][version] = {updated_at: updated_at, dependencies: JSON.parse(dependencies)}
+            end
+
+            universe_json = JSON.pretty_generate(universe)
+            universe_filename = "universe-#{Time.now.strftime("%Y-%m-%d-%H:%M:%S")}-#{Digest::SHA1.hexdigest(universe_json)}.txt"
+            IO.write(universe_filename, universe_json)
+            puts "Cookbook universe saved to #{universe_filename}"
+            exit!
+          end
+
+          if config[:node] && !(config[:env_constraints_filter_universe] && config[:env_constraints])
+            node = Chef::Node.load(config[:node])
+          else
+            node = Chef::Node.new
+            node.name('depsolver-tmp-node')
+
+            if config[:expanded_run_list]
+              unless File.file?(config[:expanded_run_list])
+                msg("ERROR: #{config[:expanded_run_list]} does not exist or is not a file.")
+                exit!
+              end
+              contents = JSON.parse(IO.read(config[:expanded_run_list]))
+              if !(contents.key?('expanded_run_list') && contents['expanded_run_list'].is_a?(Array))
+                msg("ERROR: #{config[:expanded_run_list]} does not contain an expanded run list array.")
+                exit!
+              else
+                expanded_run_list = contents['expanded_run_list']
+                expanded_run_list.each do |arg|
+                  node.run_list.add(arg)
+                end
+              end
+            else
+              run_list = name_args.map {|item| item.to_s.split(/,/) }.flatten.each{|item| item.strip! }
+              run_list.delete_if {|item| item.empty? }
+
+              run_list.each do |arg|
+                node.run_list.add(arg)
+              end
+            end
+          end
+
+          node.chef_environment = config[:environment] if config[:environment]
+
+          if config[:capture]
+            if node.chef_environment == '_default'
+              environment_cookbook_versions = Hash.new
+            else
+              environment_cookbook_versions = Chef::Environment.load(node.chef_environment).cookbook_versions
+            end
+            env = { name: node.chef_environment, cookbook_versions: environment_cookbook_versions }
+            environment_constraints_json = JSON.pretty_generate(env)
+            environment_constraints_filename = "#{node.chef_environment}-environment-#{Time.now.strftime("%Y-%m-%d-%H:%M:%S")}-#{Digest::SHA1.hexdigest(environment_constraints_json)}.txt"
+            IO.write(environment_constraints_filename, environment_constraints_json)
+            puts "Environment constraints saved to #{environment_constraints_filename}"
+
+            begin
+              universe = rest.get_rest("universe")
+              universe_json = JSON.pretty_generate(universe)
+              universe_filename = ""
+              rest.url.to_s.match(".*/organizations/(.*)/?") { universe_filename = "#{$1}-" }
+              universe_filename += "universe-#{Time.now.strftime("%Y-%m-%d-%H:%M:%S")}-#{Digest::SHA1.hexdigest(universe_json)}.txt"
+              IO.write(universe_filename, universe_json)
+              puts "Cookbook universe saved to #{universe_filename}"
+            rescue Net::HTTPServerException
+              puts "WARNING: The cookbook universe API endpoint is not available."
+              puts "WARNING: Try capturing the cookbook universe using the SQL query found in the knife-depsolver README."
+              puts "WARNING: Then convert the results using knife-depsolver's --csv-universe-to-json option"
+            end
+          end
+
+          if config[:env_constraints]
+            unless File.file?(config[:env_constraints])
+              msg("ERROR: #{config[:env_constraints]} does not exist or is not a file.")
+              exit!
+            end
+            env = JSON.parse(IO.read(config[:env_constraints]))
+            if env['name'].to_s.empty?
+              msg("ERROR: #{config[:env_constraints]} does not contain an environment name.")
+              exit!
+            else
+              node.chef_environment = env['name']
+            end
+            if !env['cookbook_versions'].is_a?(Hash)
+              msg("ERROR: #{config[:env_constraints]} does not contain a Hash of cookbook version constraints.")
+              exit!
+            else
+              environment_cookbook_versions = env['cookbook_versions']
+            end
+          end
+
+          if config[:universe]
+            unless File.file?(config[:universe])
+              msg("ERROR: #{config[:universe]} does not exist or is not a file.")
+              exit!
+            end
+            universe = JSON.parse(IO.read(config[:universe]))
+            if !universe.is_a?(Hash)
+              msg("ERROR: #{config[:universe]} does not contain a cookbook universe Hash.")
+              exit!
+            end
+          end
+
+          if config[:env_constraints_filter_universe]
+            env_constraints = environment_cookbook_versions.each_with_object({}) do |env_constraint, memo|
+              name, constraint = env_constraint
+              constraint, version = constraint.split
+              memo[name] = DepSelector::VersionConstraint.new(constraint_to_str(constraint, version))
+            end
+            universe.each do |name, versions|
+              versions.delete_if {|version, v| !env_constraints[name].include?(version)} if env_constraints[name]
+            end
+            filtered_universe_json = JSON.pretty_generate(universe)
+            filtered_universe_filename = "filtered-universe-#{Time.now.strftime("%Y-%m-%d-%H:%M:%S")}-#{Digest::SHA1.hexdigest(filtered_universe_json)}.txt"
+            IO.write(filtered_universe_filename, filtered_universe_json)
+            puts "Filtered cookbook universe saved to #{filtered_universe_filename}"
+            exit!
+          end
+
+          run_list_expansion = node.run_list.expand(node.chef_environment, 'server')
+          expanded_run_list_with_versions = run_list_expansion.recipes.with_version_constraints_strings
+
+          exit if config[:capture]
+
+          depsolver_results = Hash.new
+          if use_local_depsolver
+            env_ckbk_constraints = environment_cookbook_versions.map do |ckbk_name, ckbk_constraint|
+              [ckbk_name, ckbk_constraint.split.reverse].flatten
+            end
+
+            all_versions = universe.map do |ckbk_name, ckbk_metadata|
+              ckbk_versions = ckbk_metadata.map do |version, version_metadata|
+                [version, version_metadata['dependencies'].map { |dep_ckbk_name, dep_ckbk_constraint| [dep_ckbk_name, dep_ckbk_constraint.split.reverse].flatten }]
+              end
+              [ckbk_name, ckbk_versions]
+            end
+
+            expanded_run_list_with_split_versions = expanded_run_list_with_versions.map do |run_list_item|
+              name, version = run_list_item.split('@')
+              name.sub!(/::.*/, '')
+              version ? [name, version] : name
+            end
+
+            data = {environment_constraints: env_ckbk_constraints, all_versions: all_versions, run_list: expanded_run_list_with_split_versions, timeout_ms: timeout}
+
+            depsolver_start_time = Time.now
+
+            solution = solve(data)
+
+            depsolver_finish_time = Time.now
+
+            if solution.first == :ok
+              solution.last.map { |ckbk| ckbk_name, ckbk_version = ckbk; depsolver_results[ckbk_name] = ckbk_version.join('.') }
+            else
+              status, error_type, error_detail = solution
+              depsolver_error = { error_type => error_detail }
+            end
+          else
+            begin
+              chef_server_version = rest.get(server_url.sub(/organizations.*/, 'version')).split("\n")[0]
+            rescue Net::HTTPServerException
+              chef_server_version = "unknown"
+            end
+
+            depsolver_start_time = Time.now
+
+            ckbks = rest.post_rest("environments/" + node.chef_environment + "/cookbook_versions", { "run_list" => expanded_run_list_with_versions })
+
+            depsolver_finish_time = Time.now
+
+            ckbks.each do |name, ckbk|
+              version = ckbk.is_a?(Hash) ? ckbk['version'] : ckbk.version
+              depsolver_results[name] = version
+            end
+          end
+        rescue Net::HTTPServerException => e
+          api_error = {}
+          api_error[:error_code] = e.response.code
+          api_error[:error_message] = e.response.message
+          begin
+            api_error[:error_body] = JSON.parse(e.response.body)
+          rescue JSON::ParserError
+          end
+        rescue => e
+          msg("ERROR: #{e.message}")
+          exit!
+        ensure
+          local_software = Hash.new
+          %w(chef-dk chef dep_selector).each do |gem_name|
+            begin
+              local_software[gem_name] = Gem::Specification.find_by_name(gem_name).version
+            rescue Gem::MissingSpecError
+            end
+          end
+
+          results = {}
+          results[:local_software] = local_software unless local_software.empty?
+          if use_local_depsolver
+            results[:depsolver] = "used local depsolver"
+          else
+            results[:depsolver] = {"used chef server" => chef_server_version} unless chef_server_version.nil?
+          end
+          results[:node] = node.name unless node.nil? || node.name.nil?
+          results[:environment] = node.chef_environment unless node.chef_environment.nil?
+          results[:run_list] = node.run_list unless node.nil? || node.run_list.nil?
+          results[:expanded_run_list] = expanded_run_list_with_versions unless expanded_run_list_with_versions.nil?
+          results[:depsolver_results] = depsolver_results unless depsolver_results.nil? || depsolver_results.empty?
+          results[:depsolver_cookbook_count] = depsolver_results.count unless depsolver_results.nil? || depsolver_results.empty?
+          results[:depsolver_elapsed_ms] = ((depsolver_finish_time - depsolver_start_time) * 1000).to_i unless depsolver_finish_time.nil?
+          results[:depsolver_error] = depsolver_error unless depsolver_error.nil?
+          results[:api_error] = api_error unless api_error.nil?
+
+          if config[:capture]
+            results_json = JSON.pretty_generate(results)
+            expanded_run_list_filename = "expanded-run-list-#{Time.now.strftime("%Y-%m-%d-%H:%M:%S")}-#{Digest::SHA1.hexdigest(results_json)}.txt"
+            IO.write(expanded_run_list_filename, results_json)
+            puts "Expanded run list saved to #{expanded_run_list_filename}"
+          else
+            msg(JSON.pretty_generate(results))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-depsolver/version.rb

@@ -1,3 +1,3 @@
-module KnifeDepsolver
-  VERSION = "1.0.1"
-end
+module KnifeDepsolver
+  VERSION = "2.0.0"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-depsolver
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Jeremiah Snapp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-17 00:00:00.000000000 Z
+date: 2017-05-02 00:00:00.000000000 Z
 dependencies: []
 description: Knife plugin that uses Chef Server to calculate cookbook dependencies
   for a given run_list.
@@ -23,6 +23,7 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- lib/chef/knife/depselector.rb
 - lib/chef/knife/depsolver.rb
 - lib/knife-depsolver/version.rb
 homepage: https://github.com/jeremiahsnapp/knife-depsolver
@@ -44,10 +45,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Knife plugin that uses Chef Server to calculate cookbook dependencies for
   a given run_list.
 test_files: []
-has_rdoc: