chef-cli 1.0.3

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

@@ -0,0 +1,132 @@
+#
+# Copyright:: Copyright (c) 2017 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"
+
+module ChefCLI
+  module Policyfile
+
+    # A policyfile lock fetcher that can read a lock from a local disk
+    class LocalLockFetcher
+      include LockFetcherMixin
+
+      attr_reader :name
+      attr_reader :source_options
+      attr_reader :storage_config
+
+      # Initialize a LocalLockFetcher
+      #
+      # @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
+      # @param storage_config [StorageConfig]
+      def initialize(name, source_options, storage_config)
+        @name = name
+        @source_options = source_options
+        @storage_config = storage_config
+      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 craeting this class for errors
+      #
+      # @return [Array<String>] A list of errors found
+      def errors
+        error_messages = []
+
+        [:path].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
+        FFI_Yajl::Parser.new.parse(content).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?
+              cookbook_lock["source_options"]["path"] = transform_path(cookbook_path)
+            end
+          end
+        end
+      end
+
+      private
+
+      # Transforms cookbook paths to a path relative to the current
+      # cookbook for which we are generating a new lock file.
+      # Eg: '../cookbooks/base_cookbook'
+      #
+      # @param path_to_transform [String] Path to dependent cookbook.
+      # @return [Pathname] Path to dependent cookbook relative to the current cookbook/Policyfile.
+      def transform_path(path_to_transform)
+        cur_path = Pathname.new(storage_config.relative_paths_root)
+        include_path = Pathname.new(path).dirname
+        include_path.relative_path_from(cur_path).join(path_to_transform).to_s
+      end
+
+      def content
+        IO.read(path)
+      end
+
+      def path
+        @path ||= begin
+          path = abs_path
+          if path.directory?
+            path = path.join("#{name}.lock.json")
+            if !path.file?
+              raise ChefCLI::LocalPolicyfileLockNotFound.new(
+                "Expected to find file #{name}.lock.json inside #{source_options[:path]}. If the file name is different than this, provide the file name as part of the path.")
+            end
+          else
+            if !path.file?
+              raise ChefCLI::LocalPolicyfileLockNotFound.new(
+                "The provided path #{source_options[:path]} does not exist.")
+            end
+          end
+          path
+        end
+      end
+
+      def abs_path
+        Pathname.new(source_options[:path]).expand_path(storage_config.relative_paths_root)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+#
+# Copyright:: Copyright (c) 2017 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
+
+    # A class that can apply constraints from a lock to a compiler
+    class LockApplier
+      attr_reader :unlocked_policies
+      attr_reader :policyfile_lock
+      attr_reader :policyfile_compiler
+
+      # Initialize a LockApplier. By default, all locked data this class knows
+      # about will be applied to the compiler. Currently, it applies locks only
+      # for included policies.
+      #
+      # @param policyfile_lock [PolicyfileLock] contains the locked data to use
+      # @param policyfile_compiler [PolicyfileCompiler] the compiler to apply the locked data
+      def initialize(policyfile_lock, policyfile_compiler)
+        @policyfile_lock = policyfile_lock
+        @policyfile_compiler = policyfile_compiler
+        @unlocked_policies = []
+      end
+
+      # Unlocks included policies
+      #
+      # @param policies [:all] Unconstrain all policies
+      # @param policies [Array<String>] Unconstrain a specific policy by name
+      def with_unlocked_policies(policies)
+        if policies == :all || unlocked_policies == :all
+          @unlocked_policies = :all
+        else
+          policies.each do |policy|
+            @unlocked_policies << policy
+          end
+        end
+        self
+      end
+
+      # Apply locks described in policyfile_lock allowing for the deviations asked
+      # for.
+      #
+      # @note No changes are applied until apply! is invoked
+      def apply!
+        prepare_constraints_for_policies
+      end
+
+      private
+
+      def prepare_constraints_for_policies
+        if unlocked_policies == :all
+          return
+        end
+
+        policyfile_compiler.included_policies.each do |policy|
+          if !unlocked_policies.include?(policy.name)
+            lock = policyfile_lock.included_policy_locks.find do |policy_lock|
+              policy_lock["name"] == policy.name
+            end
+            policy.apply_locked_source_options(lock["source_options"])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+#
+# 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 "../exceptions"
+
+module ChefCLI
+  module Policyfile
+    module LockFetcherMixin
+      def validate_revision_id(included_id, source_options)
+        expected_id = source_options[:policy_revision_id]
+        if expected_id
+          if included_id.eql?(expected_id) # are they the same?
+            return
+          elsif included_id[0, 10].eql?(expected_id) # did they use the 10 char substring
+            return
+          else
+            raise ChefCLI::InvalidLockfile, "Expected policy_revision_id '#{expected_id}' does not match included_policy '#{included_id}'."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+#
+# 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 "../exceptions"
+
+module ChefCLI
+  module Policyfile
+    class NullCookbookSource
+
+      def initialize(_uri = nil)
+      end
+
+      def universe_graph
+        {}
+      end
+
+      def source_options_for(cookbook_name, cookbook_version)
+        raise UnsupportedFeature, "You must set a default_source in your Policyfile to download cookbooks without explicit sources"
+      end
+
+      def null?
+        true
+      end
+
+      def preferred_cookbooks
+        []
+      end
+
+      def desc
+        "null_cookbook_source"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+#
+# Copyright:: Copyright (c) 2017-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 "../policyfile_lock"
+require_relative "local_lock_fetcher"
+require_relative "remote_lock_fetcher"
+require_relative "chef_server_lock_fetcher"
+require_relative "git_lock_fetcher"
+require_relative "../exceptions"
+
+module ChefCLI
+  module Policyfile
+    # A PolicyfileLocationSpecification specifies where a policyfile lock is to be fetched from.
+    # Using this information, it provides a fetcher that is capable loading the policyfile
+    # lock.
+    #
+    # @attr_reader [String] name The name of the policyfile
+    # @attr_reader [Hash] source_options Options describing how to get the policyfile lock
+    class PolicyfileLocationSpecification
+      attr_reader :name
+      attr_reader :source_options
+
+      attr_reader :storage_config
+      attr_reader :chef_config
+      attr_reader :ui
+
+      LOCATION_TYPES = [:path, :remote, :server, :git].freeze
+
+      # Initialize a location spec
+      #
+      # @param name [String] the name of the policyfile
+      # @param source_options [Hash] options describing where the policyfile lock lives
+      # @param storage_config [Policyfile::StorageConfig]
+      # @param chef_config [Chef::Config] chef config that will be used when communication
+      #                    with a chef server is required
+      def initialize(name, source_options, storage_config, chef_config = nil)
+        @name = name
+        @source_options = source_options
+        @storage_config = storage_config
+        @ui = nil
+        @chef_config = chef_config
+      end
+
+      # @return The revision id from the fetched lock
+      def revision_id
+        fetcher.lock_data["revision_id"]
+      end
+
+      # @return A policyfile lock fetcher compatible with the given source_options
+      def fetcher
+        @fetcher ||= begin
+                       if source_options[:path] && !source_options[:git]
+                         Policyfile::LocalLockFetcher.new(name, source_options, storage_config)
+                       elsif source_options[:remote]
+                         Policyfile::RemoteLockFetcher.new(name, source_options)
+                       elsif source_options[:server]
+                         Policyfile::ChefServerLockFetcher.new(name, source_options, chef_config)
+                       elsif source_options[:git]
+                         Policyfile::GitLockFetcher.new(name, source_options, storage_config)
+                       else
+                         raise ChefCLI::InvalidPolicyfileLocation.new(
+                           "Invalid policyfile lock location type. The supported locations are: #{LOCATION_TYPES.join(", ")}"
+                         )
+                       end
+                     end
+      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 craeting this class for errors
+      #
+      # @return [Array<String>] A list of errors found
+      def errors
+        error_messages = []
+
+        if LOCATION_TYPES.all? { |l| source_options[l].nil? }
+          error_messages << "include_policy must use one of the following sources: #{LOCATION_TYPES.join(', ')}"
+        else
+          if !fetcher.nil?
+            error_messages += fetcher.errors
+          end
+        end
+
+        error_messages
+      end
+
+      # Fetches and loads the policyfile lock
+      #
+      # @return [PolicyfileLock] the loaded policyfile lock
+      def policyfile_lock
+        @policyfile_lock ||= begin
+                               PolicyfileLock.new(storage_config, ui: ui).build_from_lock_data(fetcher.lock_data)
+                             end
+      end
+
+      # @return [Hash] The source_options that describe how to fetch this exact lock again
+      def source_options_for_lock
+        fetcher.source_options_for_lock
+      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)
+        fetcher.apply_locked_source_options(options_from_lock)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+#
+# 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.
+#
+
+# This fixes a missing require in chef/digester:
+require "singleton" unless defined?(Singleton)
+require "chef/cookbook/cookbook_version_loader"
+require "chef/cookbook/chefignore"
+
+module ChefCLI
+  module Policyfile
+
+    class CookbookLoaderWithChefignore
+
+      # Convenience method to load a cookbook and return a
+      # Chef::CookbookVersion object.
+      #
+      def self.load(name, directory_path)
+        new(name, directory_path).cookbook_version
+      end
+
+      attr_reader :cookbook_name
+      attr_reader :directory_path
+
+      def initialize(cookbook_name, directory_path)
+        @cookbook_name = cookbook_name
+        @directory_path = directory_path
+
+        @cookbook_version = nil
+        @loader = nil
+      end
+
+      def cookbook_version
+        @cookbook_version ||= loader.cookbook_version
+      end
+
+      def loader
+        @loader ||=
+          begin
+            cbvl = Chef::Cookbook::CookbookVersionLoader.new(directory_path, chefignore)
+            cbvl.load!
+            cbvl
+          end
+      end
+
+      def chefignore
+        @chefignore ||= Chef::Cookbook::Chefignore.new(File.join(directory_path, "chefignore"))
+      end
+
+    end
+
+    # TODO: when compat mode is removed, this class should be removed and the
+    # file should be renamed
+    class ReadCookbookForCompatModeUpload
+
+      # Convenience method to load a cookbook, set up name and version overrides
+      # as necessary, and return a Chef::CookbookVersion object.
+      def self.load(name, version_override, directory_path)
+        new(name, version_override, directory_path).cookbook_version
+      end
+
+      attr_reader :cookbook_name
+      attr_reader :directory_path
+      attr_reader :version_override
+
+      def initialize(cookbook_name, version_override, directory_path)
+        @cookbook_name = cookbook_name
+        @version_override = version_override
+        @directory_path = directory_path
+
+        @cookbook_version = nil
+        @loader = nil
+      end
+
+      def cookbook_version
+        @cookbook_version ||=
+          begin
+            cookbook_version = loader.cookbook_version
+            # TODO: dont do this for non-compat mode
+            cookbook_version.version = version_override
+            # TODO: dont do this either
+
+            # Fixup manifest.
+            # What happens is, the 'manifest' representation of cookbook
+            # version is created, it has a "name" field like foo-1.0.0, then we
+            # change the version to 1234.5678.9876 but the manifest is not
+            # regenerated so erchef rejects our upload b/c the name field
+            # doesn't match the expected `$cookbook_name-$version` based on the
+            # other fields.
+            cookbook_version.manifest[:name] = "#{cookbook_version.name}-#{version_override}"
+            cookbook_version.freeze_version
+            cookbook_version
+          end
+      end
+
+      def loader
+        @loader ||=
+          begin
+            cbvl = Chef::Cookbook::CookbookVersionLoader.new(directory_path, chefignore)
+            cbvl.load!
+            cbvl
+          end
+      end
+
+      def chefignore
+        @chefignore ||= Chef::Cookbook::Chefignore.new(File.join(directory_path, "chefignore"))
+      end
+
+    end
+  end
+end