chef-apply 0.3.3 → 0.4.6

data/lib/chef_apply/minimum_chef_version.rb

@@ -1,79 +0,0 @@
-#
-# 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 "chef_apply/error"
-
-module ChefApply
-  class MinimumChefVersion
-
-    CONSTRAINTS = {
-      windows: {
-        13 => Gem::Version.new("13.10.4"),
-        14 => Gem::Version.new("14.4.22"),
-      },
-      linux: {
-        13 => Gem::Version.new("13.10.4"),
-        14 => Gem::Version.new("14.1.1"),
-      },
-    }.freeze
-
-    def self.check!(target, check_only)
-      begin
-        installed_version = target.installed_chef_version
-      rescue ChefApply::TargetHost::ChefNotInstalled
-        if check_only
-          raise ClientNotInstalled.new()
-        end
-        return :client_not_installed
-      end
-
-      os_constraints = CONSTRAINTS[target.base_os]
-      min_14_version = os_constraints[14]
-      min_13_version = os_constraints[13]
-
-      case
-        when installed_version >= Gem::Version.new("14.0.0") && installed_version < min_14_version
-          raise Client14Outdated.new(installed_version, min_14_version)
-        when installed_version >= Gem::Version.new("13.0.0") && installed_version < min_13_version
-          raise Client13Outdated.new(installed_version, min_13_version, min_14_version)
-        when installed_version < Gem::Version.new("13.0.0")
-          # If they have Chef < 13.0.0 installed we want to show them the easiest upgrade path -
-          # Chef 13 first and then Chef 14 since most customers cannot make the leap directly
-          # to 14.
-          raise Client13Outdated.new(installed_version, min_13_version, min_14_version)
-      end
-
-      :minimum_version_met
-    end
-
-    class ClientNotInstalled < ChefApply::ErrorNoLogs
-      def initialize(); super("CHEFINS002"); end
-    end
-
-    class Client13Outdated < ChefApply::ErrorNoLogs
-      def initialize(current_version, min_13_version, min_14_version)
-        super("CHEFINS003", current_version, min_13_version, min_14_version)
-      end
-    end
-
-    class Client14Outdated < ChefApply::ErrorNoLogs
-      def initialize(current_version, target_version)
-        super("CHEFINS004", current_version, target_version)
-      end
-    end
-  end
-end

data/lib/chef_apply/recipe_lookup.rb

@@ -1,117 +0,0 @@
-#
-# 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 "chef-config/config"
-require "chef_apply/config"
-require "chef_apply/error"
-require "chef_apply/log"
-
-module ChefApply
-  # When users are trying to converge a local recipe on a remote target, there
-  # is a very specific (but expansive) set of things they can specify. This
-  # class encapsulates that logic for testing purposes. We either return
-  # a path to a recipe or we raise an error.
-  class RecipeLookup
-
-    attr_reader :cookbook_repo_paths
-    def initialize(cookbook_repo_paths)
-      @cookbook_repo_paths = cookbook_repo_paths
-    end
-
-    # The recipe specifier is provided by the customer as either a path OR
-    # a cookbook and optional recipe name.
-    def split(recipe_specifier)
-      recipe_specifier.split("::")
-    end
-
-    # Given a cookbook path or name, try to load that cookbook. Either return
-    # a cookbook object or raise an error.
-    def load_cookbook(path_or_name)
-      require "chef/exceptions"
-      if File.directory?(path_or_name)
-        cookbook_path = path_or_name
-        # First, is there a cookbook in the specified dir that matches?
-        require "chef/cookbook/cookbook_version_loader"
-        begin
-          v = Chef::Cookbook::CookbookVersionLoader.new(cookbook_path)
-          v.load!
-          cookbook = v.cookbook_version
-        rescue Chef::Exceptions::CookbookNotFoundInRepo
-          raise InvalidCookbook.new(cookbook_path)
-        end
-      else
-        cookbook_name = path_or_name
-        # Second, is there a cookbook in their local repository that matches?
-        require "chef/cookbook_loader"
-        cb_loader = Chef::CookbookLoader.new(cookbook_repo_paths)
-        cb_loader.load_cookbooks
-
-        begin
-          cookbook = cb_loader[cookbook_name]
-        rescue Chef::Exceptions::CookbookNotFoundInRepo
-          cookbook_repo_paths.each do |repo_path|
-            cookbook_path = File.join(repo_path, cookbook_name)
-            if File.directory?(cookbook_path)
-              raise InvalidCookbook.new(cookbook_path)
-            end
-          end
-          raise CookbookNotFound.new(cookbook_name, cookbook_repo_paths)
-        end
-      end
-      cookbook
-    end
-
-    # Find the specified recipe or default recipe if none is specified.
-    # Raise an error if recipe cannot be found.
-    def find_recipe(cookbook, recipe_name = nil)
-      recipes = cookbook.recipe_filenames_by_name
-      if recipe_name.nil?
-        default_recipe = recipes["default"]
-        raise NoDefaultRecipe.new(cookbook.root_dir, cookbook.name) if default_recipe.nil?
-        default_recipe
-      else
-        recipe = recipes[recipe_name]
-        raise RecipeNotFound.new(cookbook.root_dir, recipe_name, recipes.keys, cookbook.name) if recipe.nil?
-        recipe
-      end
-    end
-
-    class InvalidCookbook < ChefApply::Error
-      def initialize(cookbook_path); super("CHEFVAL005", cookbook_path); end
-    end
-
-    class CookbookNotFound < ChefApply::Error
-      def initialize(cookbook_name, repo_paths)
-        repo_paths = repo_paths.join("\n")
-        super("CHEFVAL006", cookbook_name, repo_paths)
-      end
-    end
-
-    class NoDefaultRecipe < ChefApply::Error
-      def initialize(cookbook_path, cookbook_name); super("CHEFVAL007", cookbook_path, cookbook_name); end
-    end
-
-    class RecipeNotFound < ChefApply::Error
-      def initialize(cookbook_path, recipe_name, available_recipes, cookbook_name)
-        available_recipes.map! { |r| "'#{r}'" }
-        available_recipes = available_recipes.join(", ")
-        super("CHEFVAL008", cookbook_path, recipe_name, available_recipes, cookbook_name)
-      end
-    end
-
-  end
-end

data/lib/chef_apply/temp_cookbook.rb

@@ -1,170 +0,0 @@
-#
-# Copyright:: Copyright (c) 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 "tmpdir"
-require "fileutils"
-require "chef_apply/log"
-require "chef_apply/error"
-
-module ChefApply
-  # This class knows how to create a local cookbook in a temp file, populate
-  # it with various recipes, attributes, config, etc. and delete it when the
-  # cookbook is no longer necessary
-  class TempCookbook
-    attr_reader :path, :descriptor, :from
-    def initialize
-      @path = Dir.mktmpdir("cw")
-    end
-
-    def from_existing_recipe(existing_recipe_path)
-      ext_name = File.extname(existing_recipe_path)
-      raise UnsupportedExtension.new(ext_name) unless ext_name == ".rb"
-      cb = cookbook_for_recipe(existing_recipe_path)
-      if cb
-        # Full existing cookbook - only needs policyfile
-        ChefApply::Log.debug("Found full cookbook at path '#{cb[:path]}' and using recipe '#{cb[:recipe_name]}'")
-        @descriptor = "#{cb[:name]}::#{cb[:recipe_name]}"
-        @from = "#{cb[:path]}"
-        recipe_name = cb[:recipe_name]
-        cb_name = cb[:name]
-        FileUtils.cp_r(cb[:path], path)
-        # cp_r copies the whole existing cookbook into the tempdir so need to reset our path
-        @path = File.join(path, File.basename(cb[:path]))
-      else
-        # Cookbook from single recipe not in a cookbook. We create the full cookbook
-        # structure including metadata, then generate policyfile. We set the cookbook
-        # name to the recipe name so hopefully this gives us better reporting info
-        # in the future
-        ChefApply::Log.debug("Found single recipe at path '#{existing_recipe_path}'")
-        recipe = File.basename(existing_recipe_path)
-        recipe_name = File.basename(recipe, ext_name)
-        cb_name = "cw_recipe"
-        @descriptor = "#{recipe_name}"
-        @from = existing_recipe_path
-        recipes_dir = generate_recipes_dir
-        # This has the potential to break if they specify a recipe without a .rb
-        # extension, but lets wait to deal with that bug until we encounter it
-        FileUtils.cp(existing_recipe_path, File.join(recipes_dir, recipe))
-        generate_metadata(cb_name)
-      end
-      generate_policyfile(cb_name, recipe_name)
-    end
-
-    def from_resource(resource_type, resource_name, properties)
-      # Generate a cookbook containing a single default recipe with the specified
-      # resource in it. Incloud the resource type in the cookbook name so hopefully
-      # this gives us better reporting info in the future.
-      @descriptor = "#{resource_type}[#{resource_name}]"
-      @from = "resource"
-
-      ChefApply::Log.debug("Generating cookbook for single resource '#{resource_type}[#{resource_name}]'")
-      name = "cw_#{resource_type}"
-      recipe_name = "default"
-      recipes_dir = generate_recipes_dir
-      File.open(File.join(recipes_dir, "#{recipe_name}.rb"), "w+") do |f|
-        f.print(create_resource_definition(resource_type, resource_name, properties))
-      end
-      generate_metadata(name)
-      generate_policyfile(name, recipe_name)
-    end
-
-    def delete
-      FileUtils.remove_entry path
-    end
-
-    def cookbook_for_recipe(existing_recipe_path)
-      metadata = File.expand_path(File.join(existing_recipe_path, "../../metadata.rb"))
-      if File.file?(metadata)
-        require "chef/cookbook/metadata"
-        m = Chef::Cookbook::Metadata.new
-        m.from_file(metadata)
-        {
-          name: m.name,
-          recipe_name: File.basename(existing_recipe_path, File.extname(existing_recipe_path)),
-          path: File.expand_path(File.join(metadata, "../")),
-        }
-      else
-        nil
-      end
-    end
-
-    def generate_recipes_dir
-      recipes_path = File.join(path, "recipes")
-      FileUtils.mkdir_p(recipes_path)
-      recipes_path
-    end
-
-    def generate_metadata(name)
-      metadata_file = File.join(path, "metadata.rb")
-      File.open(metadata_file, "w+") do |f|
-        f.print("name \"#{name}\"\n")
-      end
-      metadata_file
-    end
-
-    def generate_policyfile(name, recipe_name)
-      policy_file = File.join(path, "Policyfile.rb")
-      if File.exist?(policy_file)
-        File.open(policy_file, "a") do |f|
-          # We override the specified run_list with the run_list we want.
-          # We append and put this at the end of the file so it overrides
-          # any specified run_list.
-          f.print("\n# Overriding run_list with command line specified value\n")
-          f.print("run_list \"#{name}::#{recipe_name}\"\n")
-        end
-      else
-        File.open(policy_file, "w+") do |f|
-          f.print("name \"#{name}_policy\"\n")
-          ChefApply::Config.chef.cookbook_repo_paths.each do |p|
-            f.print("default_source :chef_repo, \"#{p}\"\n")
-          end
-          f.print("default_source :supermarket\n")
-          f.print("run_list \"#{name}::#{recipe_name}\"\n")
-          f.print("cookbook \"#{name}\", path: \".\"\n")
-        end
-      end
-      policy_file
-    end
-
-    def create_resource_definition(resource_type, resource_name, properties)
-      r = "#{resource_type} '#{resource_name}'"
-      # lets format the properties into the correct syntax Chef expects
-      unless properties.empty?
-        r += " do\n"
-        properties.each do |k, v|
-          v = "'#{v}'" if v.is_a? String
-          r += "  #{k} #{v}\n"
-        end
-        r += "end"
-      end
-      r += "\n"
-      r
-    end
-
-    def policyfile_lock_path
-      File.join(path, "Policyfile.lock.json")
-    end
-
-    def export_path
-      File.join(path, "export")
-    end
-
-    class UnsupportedExtension < ChefApply::ErrorNoLogs
-      def initialize(ext); super("CHEFVAL009", ext); end
-    end
-  end
-end