chef-cli 1.0.3

data/lib/chef-cli/policyfile/remote_lock_fetcher.rb

@@ -0,0 +1,108 @@
+#
+# Copyright:: Copyright (c) 2019 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../policyfile_lock"
+require_relative "lock_fetcher_mixin"
+require_relative "../exceptions"
+require "chef/http"
+require "tempfile" unless defined?(Tempfile)
+
+module ChefCLI
+  module Policyfile
+
+    # A policyfile lock fetcher that can read a lock from a remote location.
+    class RemoteLockFetcher
+      include LockFetcherMixin
+
+      attr_reader :name
+      attr_reader :source_options
+
+      # Initialize a RemoteLockFetcher
+      #
+      # @param name [String] The name of the policyfile
+      # @param source_options [Hash] A hash with a :path key pointing at the location
+      #                              of the lock
+      def initialize(name, source_options)
+        @name = name
+        @source_options = source_options
+      end
+
+      # @return [True] if there were no errors with the provided source_options
+      # @return [False] if there were errors with the provided source_options
+      def valid?
+        errors.empty?
+      end
+
+      # Check the options provided when creating this class for errors
+      #
+      # @return [Array<String>] A list of errors found
+      def errors
+        error_messages = []
+
+        [:remote].each do |key|
+          error_messages << "include_policy for #{name} is missing key #{key}" unless source_options[key]
+        end
+
+        error_messages
+      end
+
+      # @return [Hash] The source_options that describe how to fetch this exact lock again
+      def source_options_for_lock
+        source_options
+      end
+
+      # Applies source options from a lock file. This is used to make sure that the same
+      # policyfile lock is loaded that was locked
+      #
+      # @param options_from_lock [Hash] The source options loaded from a policyfile lock
+      def apply_locked_source_options(options_from_lock)
+        # There are no options the lock could provide
+      end
+
+      # @return [String] of the policyfile lock data
+      def lock_data
+        fetch_lock_data.tap do |data|
+          validate_revision_id(data["revision_id"], source_options)
+          data["cookbook_locks"].each do |cookbook_name, cookbook_lock|
+            cookbook_path = cookbook_lock["source_options"]["path"]
+            if !cookbook_path.nil?
+              raise ChefCLI::InvalidLockfile, "Invalid cookbook path: #{cookbook_path}. Remote Policyfiles should only use remote cookbooks."
+            end
+          end
+        end
+      end
+
+      private
+
+      def fetch_lock_data
+        FFI_Yajl::Parser.parse(http_client.get(""))
+      rescue Net::ProtocolError => e
+        if e.respond_to?(:response) && e.response.code.to_s == "404"
+          raise ChefCLI::PolicyfileLockDownloadError.new("No remote policyfile lock '#{name}' found at #{http_client.url}")
+        else
+          raise ChefCLI::PolicyfileLockDownloadError.new("HTTP error attempting to fetch policyfile lock from #{http_client.url}")
+        end
+      rescue => e
+        raise e
+      end
+
+      def http_client
+        @http_client ||= Chef::HTTP.new(source_options[:remote])
+      end
+    end
+  end
+end

data/lib/chef-cli/policyfile/reports/install.rb

@@ -0,0 +1,69 @@
+#
+# Copyright:: Copyright (c) 2014-2018 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "table_printer"
+
+module ChefCLI
+  module Policyfile
+    module Reports
+
+      class Install
+
+        attr_reader :ui
+        attr_reader :policyfile_compiler
+
+        def initialize(ui: nil, policyfile_compiler: nil)
+          @ui = ui
+          @policyfile_compiler = policyfile_compiler
+
+          @fixed_version_install_table = nil
+          @install_table = nil
+        end
+
+        def installing_fixed_version_cookbook(cookbook_spec)
+          verb = cookbook_spec.installed? ? "Using     " : "Installing"
+          fixed_version_install_table.print_row(verb, cookbook_spec.name, cookbook_spec.version_constraint.to_s, "from #{cookbook_spec.source_type}")
+        end
+
+        def installing_cookbook(cookbook_spec)
+          verb = cookbook_spec.installed? ? "Using     " : "Installing"
+          install_table.print_row(verb, cookbook_spec.name, cookbook_spec.version_constraint.version)
+        end
+
+        private
+
+        def fixed_version_install_table
+          @fixed_version_install_table ||= TablePrinter.new(ui) do |t|
+            t.column(%w{Using Installing})
+            t.column(policyfile_compiler.fixed_version_cookbooks_specs.keys)
+            t.column
+            t.column
+          end
+        end
+
+        def install_table
+          @install_table ||= TablePrinter.new(ui) do |t|
+            t.column(%w{Using Installing})
+            t.column(policyfile_compiler.graph_solution.keys)
+            t.column(policyfile_compiler.graph_solution.values)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/chef-cli/policyfile/reports/table_printer.rb

@@ -0,0 +1,57 @@
+#
+# Copyright:: Copyright (c) 2014-2018 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module ChefCLI
+  module Policyfile
+    module Reports
+
+      # Defines a table with a flexible number of columns and prints rows in
+      # the table. Columns are defined ahead of time, by calling the #column
+      # method, individual rows are printed by calling #print_row with the data
+      # for each cell.
+      class TablePrinter
+
+        attr_reader :ui
+
+        def initialize(ui)
+          @ui = ui
+          @column_widths = []
+
+          yield self
+        end
+
+        # Defines a column. If a collection is given, it is mapped to an array
+        # of strings and the longest string is used as the left justify width
+        # for that column when rows are printed.
+        def column(collection = [])
+          @column_widths << (collection.map(&:to_s).map(&:size).max || 0)
+        end
+
+        # Print a row.
+        def print_row(*cells)
+          row = ""
+          cells.each_with_index do |cell_data, i|
+            row << cell_data.to_s.ljust(@column_widths[i])
+            row << " "
+          end
+          ui.msg(row.strip)
+        end
+
+      end
+    end
+  end
+end

data/lib/chef-cli/policyfile/reports/upload.rb

@@ -0,0 +1,70 @@
+#
+# Copyright:: Copyright (c) 2014-2018 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "table_printer"
+
+module ChefCLI
+  module Policyfile
+    module Reports
+      class Upload
+
+        attr_reader :reused_cbs
+        attr_reader :uploaded_cbs
+        attr_reader :ui
+
+        def initialize(reused_cbs: [], uploaded_cbs: [], ui: nil)
+          @reused_cbs = reused_cbs
+          @uploaded_cbs = uploaded_cbs
+          @ui = ui
+
+          @justify_name_width = nil
+          @justify_version_width = nil
+        end
+
+        def show
+          reused_cbs.each do |cb_with_lock|
+            lock = cb_with_lock.lock
+            table.print_row("Using", lock.name, lock.version, "(#{lock.identifier[0, 8]})")
+          end
+
+          uploaded_cbs.each do |cb_with_lock|
+            lock = cb_with_lock.lock
+            table.print_row("Uploaded", lock.name, lock.version, "(#{lock.identifier[0, 8]})")
+          end
+        end
+
+        def table
+          @table ||= TablePrinter.new(ui) do |t|
+            t.column(%w{ Using Uploaded })
+            t.column(cookbook_names)
+            t.column(cookbook_version_numbers)
+            t.column
+          end
+        end
+
+        def cookbook_names
+          (reused_cbs + uploaded_cbs).map { |e| e.lock.name }
+        end
+
+        def cookbook_version_numbers
+          (reused_cbs + uploaded_cbs).map { |e| e.lock.version }
+        end
+
+      end
+    end
+  end
+end

data/lib/chef-cli/policyfile/solution_dependencies.rb

@@ -0,0 +1,311 @@
+#
+# Copyright:: Copyright (c) 2014-2018, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "semverse"
+require "set" unless defined?(Set)
+require_relative "../exceptions"
+
+module ChefCLI
+  module Policyfile
+
+    class SolutionDependencies
+
+      Cookbook = Struct.new(:name, :version)
+
+      class Cookbook
+
+        VALID_STRING_FORMAT = /\A[^\s]+ \([^\s]+\)\Z/.freeze
+
+        def self.valid_str?(str)
+          !!(str =~ VALID_STRING_FORMAT)
+        end
+
+        def self.parse(str)
+          name, version_w_parens = str.split(" ")
+          version = version_w_parens[/\(([^)]+)\)/, 1]
+          new(name, version)
+        end
+
+        def to_s
+          "#{name} (#{version})"
+        end
+
+        def eql?(other)
+          other.kind_of?(self.class) &&
+            other.name == name &&
+            other.version == version
+        end
+
+        def hash
+          [name, version].hash
+        end
+
+      end
+
+      def self.from_lock(lock_data)
+        new.tap { |e| e.consume_lock_data(lock_data) }
+      end
+
+      attr_reader :policyfile_dependencies
+
+      attr_reader :cookbook_dependencies
+
+      def initialize
+        @policyfile_dependencies = []
+        @cookbook_dependencies = {}
+      end
+
+      def add_policyfile_dep(cookbook, constraint)
+        @policyfile_dependencies << [ cookbook, Semverse::Constraint.new(constraint) ]
+      end
+
+      def add_cookbook_dep(cookbook_name, version, dependency_list)
+        cookbook = Cookbook.new(cookbook_name, version)
+        add_cookbook_obj_dep(cookbook, dependency_list)
+      end
+
+      def update_cookbook_dep(cookbook_name, new_version, new_dependency_list)
+        @cookbook_dependencies.delete_if { |cb, _deps| cb.name == cookbook_name }
+        add_cookbook_dep(cookbook_name, new_version, new_dependency_list)
+      end
+
+      def consume_lock_data(lock_data)
+        unless lock_data.key?("Policyfile") && lock_data.key?("dependencies")
+          msg = %Q|lockfile solution_dependencies must be a Hash of the form `{"Policyfile": [], "dependencies": {} }' (got: #{lock_data.inspect})|
+          raise InvalidLockfile, msg
+        end
+
+        set_policyfile_deps_from_lock_data(lock_data)
+        set_cookbook_deps_from_lock_data(lock_data)
+      end
+
+      def test_conflict!(cookbook_name, version)
+        unless have_cookbook_dep?(cookbook_name, version)
+          raise CookbookNotInWorkingSet, "Cookbook #{cookbook_name} (#{version}) not in the working set, cannot test for conflicts"
+        end
+
+        assert_cookbook_version_valid!(cookbook_name, version)
+        assert_cookbook_deps_valid!(cookbook_name, version)
+      end
+
+      def to_lock
+        { "Policyfile" => policyfile_dependencies_for_lock, "dependencies" => cookbook_deps_for_lock }
+      end
+
+      def policyfile_dependencies_for_lock
+        policyfile_dependencies.map do |name, constraint|
+          [ name, constraint.to_s ]
+        end.sort
+      end
+
+      def cookbook_deps_for_lock
+        cookbook_dependencies.inject({}) do |map, (cookbook, deps)|
+          map[cookbook.to_s] = deps.map do |name, constraint|
+            [ name, constraint.to_s ]
+          end
+          map
+        end.sort.to_h
+      end
+
+      def transitive_deps(names)
+        deps = Set.new
+        to_explore = names.dup
+        until to_explore.empty?
+          ck_name = to_explore.shift
+          next unless deps.add?(ck_name) # explore each ck only once
+          my_deps = find_cookbook_dep_by_name(ck_name)
+          dep_names = my_deps[1].map(&:first)
+          to_explore += dep_names
+        end
+        deps.to_a.sort
+      end
+
+      private
+
+      def add_cookbook_obj_dep(cookbook, dependency_map)
+        @cookbook_dependencies[cookbook] = dependency_map.map do |dep_name, constraint|
+          [ dep_name, Semverse::Constraint.new(constraint) ]
+        end
+      end
+
+      def assert_cookbook_version_valid!(cookbook_name, version)
+        policyfile_conflicts = policyfile_conflicts_with(cookbook_name, version)
+        cookbook_conflicts = cookbook_conflicts_with(cookbook_name, version)
+        all_conflicts = policyfile_conflicts + cookbook_conflicts
+
+        return false if all_conflicts.empty?
+
+        details = all_conflicts.map { |source, name, constraint| "#{source} depends on #{name} #{constraint}" }
+        message = "Cookbook #{cookbook_name} (#{version}) conflicts with other dependencies:\n"
+        full_message = message + details.join("\n")
+        raise DependencyConflict, full_message
+      end
+
+      def assert_cookbook_deps_valid!(cookbook_name, version)
+        dependency_conflicts = cookbook_deps_conflicts_for(cookbook_name, version)
+        return false if dependency_conflicts.empty?
+        message = "Cookbook #{cookbook_name} (#{version}) has dependency constraints that cannot be met by the existing cookbook set:\n"
+        full_message = message + dependency_conflicts.join("\n")
+        raise DependencyConflict, full_message
+      end
+
+      def policyfile_conflicts_with(cookbook_name, version)
+        policyfile_conflicts = []
+
+        @policyfile_dependencies.each do |dep_name, constraint|
+          if dep_name == cookbook_name && !constraint.satisfies?(version)
+            policyfile_conflicts << ["Policyfile", dep_name, constraint]
+          end
+        end
+
+        policyfile_conflicts
+      end
+
+      def cookbook_conflicts_with(cookbook_name, version)
+        cookbook_conflicts = []
+
+        @cookbook_dependencies.each do |top_level_dep_name, dependencies|
+          dependencies.each do |dep_name, constraint|
+            if dep_name == cookbook_name && !constraint.satisfies?(version)
+              cookbook_conflicts << [top_level_dep_name, dep_name, constraint]
+            end
+          end
+        end
+
+        cookbook_conflicts
+      end
+
+      def cookbook_deps_conflicts_for(cookbook_name, version)
+        conflicts = []
+        transitive_deps = find_cookbook_dep_by_name_and_version(cookbook_name, version)
+        transitive_deps.each do |name, constraint|
+          existing_cookbook = find_cookbook_dep_by_name(name)
+          if existing_cookbook.nil?
+            conflicts << "Cookbook #{name} isn't included in the existing cookbook set."
+          elsif !constraint.satisfies?(existing_cookbook[0].version)
+            conflicts << "Dependency on #{name} #{constraint} conflicts with existing version #{existing_cookbook[0]}"
+          end
+        end
+        conflicts
+      end
+
+      def have_cookbook_dep?(name, version)
+        @cookbook_dependencies.key?(Cookbook.new(name, version))
+      end
+
+      def find_cookbook_dep_by_name(name)
+        @cookbook_dependencies.find { |k, v| k.name == name }
+      end
+
+      def find_cookbook_dep_by_name_and_version(name, version)
+        @cookbook_dependencies[Cookbook.new(name, version)]
+      end
+
+      def set_policyfile_deps_from_lock_data(lock_data)
+        policyfile_deps_data = lock_data["Policyfile"]
+
+        unless policyfile_deps_data.kind_of?(Array)
+          msg = "lockfile solution_dependencies Policyfile dependencies must be an array of cookbooks and constraints (got: #{policyfile_deps_data.inspect})"
+          raise InvalidLockfile, msg
+        end
+
+        policyfile_deps_data.each do |entry|
+          add_policyfile_dep_from_lock_data(entry)
+        end
+      end
+
+      def add_policyfile_dep_from_lock_data(entry)
+        unless entry.kind_of?(Array) && entry.size == 2
+          msg = %Q{lockfile solution_dependencies Policyfile dependencies entry must be like [ "$COOKBOOK_NAME", "$CONSTRAINT" ] (got: #{entry.inspect})}
+          raise InvalidLockfile, msg
+        end
+
+        cookbook_name, constraint = entry
+
+        unless cookbook_name.kind_of?(String) && !cookbook_name.empty?
+          msg = "lockfile solution_dependencies Policyfile dependencies entry. Cookbook name portion must be a string (got: #{entry.inspect})"
+          raise InvalidLockfile, msg
+        end
+
+        unless constraint.kind_of?(String) && !constraint.empty?
+          msg = "malformed lockfile solution_dependencies Policyfile dependencies entry. Version constraint portion must be a string (got: #{entry.inspect})"
+          raise InvalidLockfile, msg
+        end
+        add_policyfile_dep(cookbook_name, constraint)
+      rescue Semverse::InvalidConstraintFormat
+        msg = "malformed lockfile solution_dependencies Policyfile dependencies entry. Version constraint portion must be a valid version constraint (got: #{entry.inspect})"
+        raise InvalidLockfile, msg
+      end
+
+      def set_cookbook_deps_from_lock_data(lock_data)
+        cookbook_dependencies_data = lock_data["dependencies"]
+
+        unless cookbook_dependencies_data.kind_of?(Hash)
+          msg = "lockfile solution_dependencies dependencies entry must be a Hash (JSON object) of dependencies (got: #{cookbook_dependencies_data.inspect})"
+          raise InvalidLockfile, msg
+        end
+
+        cookbook_dependencies_data.each do |name_and_version, deps_list|
+          add_cookbook_dep_from_lock_data(name_and_version, deps_list)
+        end
+      end
+
+      def add_cookbook_dep_from_lock_data(name_and_version, deps_list)
+        unless name_and_version.kind_of?(String)
+          show = "#{name_and_version.inspect} => #{deps_list.inspect}"
+          msg = %Q{lockfile cookbook_dependencies entries must be of the form "$COOKBOOK_NAME ($VERSION)" => [ $dependency, ...] (got: #{show}) }
+          raise InvalidLockfile, msg
+        end
+
+        unless Cookbook.valid_str?(name_and_version)
+          msg = %Q{lockfile cookbook_dependencies entry keys must be of the form "$COOKBOOK_NAME ($VERSION)" (got: #{name_and_version.inspect}) }
+          raise InvalidLockfile, msg
+        end
+
+        unless deps_list.kind_of?(Array)
+          msg = %Q{lockfile cookbook_dependencies entry values must be an Array like [ [ "$COOKBOOK_NAME", "$CONSTRAINT" ], ... ] (got: #{deps_list.inspect}) }
+          raise InvalidLockfile, msg
+        end
+
+        deps_list.each do |entry|
+
+          unless entry.kind_of?(Array) && entry.size == 2
+            msg = %Q{lockfile solution_dependencies dependencies entry must be like [ "$COOKBOOK_NAME", "$CONSTRAINT" ] (got: #{entry.inspect})}
+            raise InvalidLockfile, msg
+          end
+
+          dep_name, constraint = entry
+
+          unless dep_name.kind_of?(String) && !dep_name.empty?
+            msg = "malformed lockfile solution_dependencies dependencies entry. Cookbook name portion must be a string (got: #{entry.inspect})"
+            raise InvalidLockfile, msg
+          end
+
+          unless constraint.kind_of?(String) && !constraint.empty?
+            msg = "malformed lockfile solution_dependencies dependencies entry. Version constraint portion must be a string (got: #{entry.inspect})"
+            raise InvalidLockfile, msg
+          end
+        end
+
+        cookbook = Cookbook.parse(name_and_version)
+        add_cookbook_obj_dep(cookbook, deps_list)
+      end
+
+    end
+
+  end
+end