chef-apply 0.3.3 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67da1832dc2cff37ca34e9e6cd98a740915779c88ff2367096676c6204d6f390
-  data.tar.gz: 8febd165b01039b41427ba7406c209436ece3ac6dc8e93ab4fbfbd1a186e994e
+  metadata.gz: 79e301aab0d20ec072e87597869b55d24958945f0fb1cfa774841929cb5eaa80
+  data.tar.gz: e34804469b8ed16dfc9729f3229abc60d0714358146f04ca3a494a70dcef6a96
 SHA512:
-  metadata.gz: 20a22779d89a97deed72a0e36fe93ebe489b2004368a5e87e4b5e69c668238e5747af817bf99d4d628c7ca583f91887c810441be9e5326068f6b89809f48a7b2
-  data.tar.gz: d7d32da1d04bfb11b7fcd4e886bfe57fdb8517d0c6d3c21243a5a0279a969c324d2c4ac77536bf8c589ebb3c11aeabb0b3fe2ee2d308dff53add6fb6cbde8e32
+  metadata.gz: 251203d054f4ee1c8319b4b12e40a2778008f603e79530750875686facc0b2a8ec72e40425a1f643e91187882224b04af6a0c6d36698f7d341a35e104ed2c036
+  data.tar.gz: 107872f223933ca095df7e46afbf22f1260c05339531fb8c51c2e54007203e63f4e4ea4089f30abd75e2a20bd09bd1d4e56d44d21fb278e5e36e04d5db655ff7

data/Rakefile

@@ -39,4 +39,4 @@ task :console do
   IRB.start
 end
 
-task default: [:style, :spec]
+task default: %i{style spec}

data/chef-apply.gemspec

@@ -48,7 +48,8 @@ Gem::Specification.new do |spec|
                                      # localization gem...
   spec.add_dependency "toml-rb" # This isn't ideal because mixlib-config uses 'tomlrb'
                                 # but that library does not support a dumper
-  spec.add_dependency "train" # remote connection management over ssh, winrm
+  spec.add_dependency "train", "~> 3.0" # remote connection management over ssh, winrm
+  spec.add_dependency "train-winrm" # winrm transports were pulled out into this plugin
   spec.add_dependency "pastel" # A color library
   spec.add_dependency "tty-spinner" # Pretty output for status updates in the CLI
   spec.add_dependency "chef", ">= 15.0" # Needed to load cookbooks

data/lib/chef_apply/action/base.rb

@@ -65,6 +65,7 @@ module ChefApply
 
       def notify(action, *args)
         return if @notification_handler.nil?
+
         ChefApply::Log.debug("[#{self.class.name}] Action: #{action}, Action Data: #{args}")
         @notification_handler.call(action, args) if @notification_handler
       end

data/lib/chef_apply/action/converge_target.rb

@@ -26,7 +26,7 @@ module ChefApply::Action
 
     def perform_action
       local_policy_path = config.delete :local_policy_path
-      remote_tmp = target_host.temp_dir()
+      remote_tmp = target_host.temp_dir
       remote_dir_path = target_host.normalize_path(remote_tmp)
       # Ensure the directory is owned by the connecting user,
       # otherwise we won't be able to put things into it over scp as that user.
@@ -38,8 +38,8 @@ module ChefApply::Action
       notify(:running_chef)
       # TODO - just teach target_host how to run_chef?
       cmd_str = run_chef_cmd(remote_dir_path,
-                             File.basename(remote_config_path),
-                             File.basename(remote_policy_path))
+        File.basename(remote_config_path),
+        File.basename(remote_policy_path))
       c = target_host.run_command(cmd_str)
       target_host.del_dir(remote_dir_path)
       if c.exit_status == 0
@@ -52,7 +52,7 @@ module ChefApply::Action
         ChefApply::Log.error("Error running command [#{cmd_str}]")
         ChefApply::Log.error("stdout: #{c.stdout}")
         ChefApply::Log.error("stderr: #{c.stderr}")
-        handle_ccr_error()
+        handle_ccr_error
       end
     end
 
@@ -63,7 +63,7 @@ module ChefApply::Action
         target_host.upload_file(local_policy_path, remote_policy_path)
       rescue RuntimeError => e
         ChefApply::Log.error(e)
-        raise PolicyUploadFailed.new()
+        raise PolicyUploadFailed.new
       end
       remote_policy_path
     end
@@ -92,7 +92,7 @@ module ChefApply::Action
       # (we don't set a location because we want output to
       #   go in stdout for reporting back to chef-apply)
       log_settings = ChefApply::Config.log
-      if !log_settings.target_level.nil?
+      unless log_settings.target_level.nil?
         workstation_rb << <<~EOM
           log_level :#{log_settings.target_level}
         EOM
@@ -115,7 +115,7 @@ module ChefApply::Action
         config_file.close
         target_host.upload_file(config_file.path, remote_config_path)
       rescue RuntimeError
-        raise ConfigUploadFailed.new()
+        raise ConfigUploadFailed.new
       ensure
         config_file.unlink
       end
@@ -126,14 +126,14 @@ module ChefApply::Action
       remote_handler_path = File.join(remote_dir, "reporter.rb")
       begin
         # TODO - why don't we upload the original remote_handler_path instead of making a temp copy?
-        handler_file = Tempfile.new()
+        handler_file = Tempfile.new
         # TODO - ideally this is a resource in the gem, and not placed in with source files.
         handler_file.write(File.read(File.join(__dir__, "reporter.rb")))
         handler_file.close
         target_host.upload_file(handler_file.path, remote_handler_path)
       # TODO - should we be more specific in our error catch?
       rescue RuntimeError
-        raise HandlerUploadFailed.new()
+        raise HandlerUploadFailed.new
       ensure
         handler_file.unlink
       end
@@ -159,7 +159,7 @@ module ChefApply::Action
     end
 
     def handle_ccr_error
-      require "chef_apply/errors/ccr_failure_mapper"
+      require "chef_apply/action/converge_target/ccr_failure_mapper"
       mapper_opts = {}
       content = target_host.fetch_file_contents(chef_report_path)
       if content.nil?
@@ -175,7 +175,7 @@ module ChefApply::Action
         ChefApply::Log.error("Remote chef-client error follows:")
         ChefApply::Log.error(report["exception"])
       end
-      mapper = ChefApply::Errors::CCRFailureMapper.new(report["exception"], mapper_opts)
+      mapper = ConvergeTarget::CCRFailureMapper.new(report["exception"], mapper_opts)
       mapper.raise_mapped_exception!
     end
 

data/lib/chef_apply/action/converge_target/ccr_failure_mapper.rb

@@ -0,0 +1,100 @@
+#
+# 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
+  module Action
+    class ConvergeTarget
+      # This converts chef client run failures
+      # to human-friendly exceptions with detail
+      # and remediation steps based on the failure type.
+      class CCRFailureMapper
+        attr_reader :params
+
+        def initialize(exception, params)
+          @params = params
+          @cause_line = exception
+        end
+
+        def raise_mapped_exception!
+          if @cause_line.nil?
+            raise RemoteChefRunFailedToResolveError.new(params[:failed_report_path])
+          else
+            errid, *args = exception_args_from_cause
+            if errid.nil?
+              raise RemoteChefClientRunFailedUnknownReason.new
+            else
+              raise RemoteChefClientRunFailed.new(errid, *args)
+            end
+
+          end
+        end
+
+        # Ideally we will write a custom handler to package up data we care
+        # about and present it more directly  https://docs.chef.io/handlers.html
+        # For now, we'll just match the most common failures based on their
+        # messages.
+        def exception_args_from_cause
+          # Ordering is important below.  Some earlier tests are more detailed
+          # cases of things that will match more general tests further down.
+          case @cause_line
+          when /.*had an error:(.*:)\s+(.*$)/
+            # Some invalid property value cases, among others.
+            ["CHEFCCR002", $2]
+          when /.*Chef::Exceptions::ValidationFailed:\s+Option action must be equal to one of:\s+(.*)!\s+You passed :(.*)\./
+            # Invalid action - specialization of invalid property value, below
+            ["CHEFCCR003", $2, $1]
+          when /.*Chef::Exceptions::ValidationFailed:\s+(.*)/
+            # Invalid resource property value
+            ["CHEFCCR004", $1]
+          when /.*NameError: undefined local variable or method `(.+)' for cookbook.+/
+            # Invalid resource type in most cases
+            ["CHEFCCR005", $1]
+          when /.*NoMethodError: undefined method `(.+)' for cookbook.+/
+            # Invalid resource type in most cases
+            ["CHEFCCR005", $1]
+          when /.*undefined method `(.*)' for (.+)/
+            # Unknown resource property
+            ["CHEFCCR006", $1, $2]
+
+            # Below would catch the general form of most errors, but the
+            # message itself in those lines is not generally aligned
+            # with the UX we want to provide.
+            # when /.*Exception|Error.*:\s+(.*)/
+          else
+            nil
+          end
+        end
+
+        class RemoteChefClientRunFailed < ChefApply::ErrorNoLogs
+          def initialize(id, *args); super(id, *args); end
+        end
+
+        class RemoteChefClientRunFailedUnknownReason < ChefApply::ErrorNoStack
+          def initialize(); super("CHEFCCR099"); end
+        end
+
+        class RemoteChefRunFailedToResolveError < ChefApply::ErrorNoStack
+          def initialize(path); super("CHEFCCR001", path); end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/chef_apply/action/generate_local_policy.rb

@@ -49,7 +49,7 @@ module ChefApply::Action
       require "chef-cli/policyfile_services/install"
       require "chef-cli/ui"
       @installer ||=
-        ChefCLI::PolicyfileServices::Install.new(ui: ChefCLI::UI.null(), root_dir: @cookbook.path)
+        ChefCLI::PolicyfileServices::Install.new(ui: ChefCLI::UI.null, root_dir: @cookbook.path)
     end
 
   end

data/lib/chef_apply/action/generate_temp_cookbook.rb

@@ -14,73 +14,73 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 require "chef_apply/action/base"
-require "chef_apply/temp_cookbook"
 require "chef_apply/error"
+module ChefApply
+  module Action
+    class GenerateTempCookbook < Base
+      attr_reader :generated_cookbook
 
-module ChefApply::Action
-  class GenerateTempCookbook < Base
-    attr_reader :generated_cookbook
+      def self.from_options(opts)
+        if opts.key?(:recipe_spec)
+          GenerateCookbookFromRecipe.new(opts)
+        elsif opts.key?(:resource_name) &&
+            opts.key?(:resource_type) &&
+            opts.key?(:resource_properties)
+          GenerateCookbookFromResource.new(opts)
+        else
+          raise MissingOptions.new(opts)
+        end
+      end
 
-    def self.from_options(opts)
-      if opts.key?(:recipe_spec)
-        GenerateCookbookFromRecipe.new(opts)
-      elsif opts.key?(:resource_name) &&
-          opts.key?(:resource_type) &&
-          opts.key?(:resource_properties)
-        GenerateCookbookFromResource.new(opts)
-      else
-        raise MissingOptions.new(opts)
+      def initialize(options)
+        super(options)
+        require "chef_apply/action/generate_temp_cookbook/temp_cookbook"
+        @generated_cookbook ||= TempCookbook.new
       end
-    end
 
-    def initialize(options)
-      super(options)
-      @generated_cookbook ||= ChefApply::TempCookbook.new
-    end
+      def perform_action
+        notify(:generating)
+        generate
+        notify(:success)
+      end
 
-    def perform_action
-      notify(:generating)
-      generate
-      notify(:success)
+      def generate
+        raise NotImplemented
+      end
     end
 
-    def generate
-      raise NotImplemented
+    class GenerateCookbookFromRecipe < GenerateTempCookbook
+      def generate
+        recipe_specifier = config.delete :recipe_spec
+        repo_paths = config.delete :cookbook_repo_paths
+        ChefApply::Log.debug("Beginning to look for recipe specified as #{recipe_specifier}")
+        if File.file?(recipe_specifier)
+          ChefApply::Log.debug("#{recipe_specifier} is a valid path to a recipe")
+          recipe_path = recipe_specifier
+        else
+          require "chef_apply/action/generate_temp_cookbook/recipe_lookup"
+          rl = RecipeLookup.new(repo_paths)
+          cookbook_path_or_name, optional_recipe_name = rl.split(recipe_specifier)
+          cookbook = rl.load_cookbook(cookbook_path_or_name)
+          recipe_path = rl.find_recipe(cookbook, optional_recipe_name)
+        end
+        generated_cookbook.from_existing_recipe(recipe_path)
+      end
     end
-  end
 
-  class GenerateCookbookFromRecipe < GenerateTempCookbook
-    def generate
-      recipe_specifier = config.delete :recipe_spec
-      repo_paths = config.delete :cookbook_repo_paths
-      ChefApply::Log.debug("Beginning to look for recipe specified as #{recipe_specifier}")
-      if File.file?(recipe_specifier)
-        ChefApply::Log.debug("#{recipe_specifier} is a valid path to a recipe")
-        recipe_path = recipe_specifier
-      else
-        require "chef_apply/recipe_lookup"
-        rl = ChefApply::RecipeLookup.new(repo_paths)
-        cookbook_path_or_name, optional_recipe_name = rl.split(recipe_specifier)
-        cookbook = rl.load_cookbook(cookbook_path_or_name)
-        recipe_path = rl.find_recipe(cookbook, optional_recipe_name)
+    class GenerateCookbookFromResource < GenerateTempCookbook
+      def generate
+        type = config.delete :resource_type
+        name = config.delete :resource_name
+        props = config.delete :resource_properties
+        ChefApply::Log.debug("Generating cookbook for ad-hoc resource #{type}[#{name}]")
+        generated_cookbook.from_resource(type, name, props)
       end
-      generated_cookbook.from_existing_recipe(recipe_path)
     end
-  end
 
-  class GenerateCookbookFromResource < GenerateTempCookbook
-    def generate
-      type = config.delete :resource_type
-      name = config.delete :resource_name
-      props = config.delete :resource_properties
-      ChefApply::Log.debug("Generating cookbook for ad-hoc resource #{type}[#{name}]")
-      generated_cookbook.from_resource(type, name, props)
+    class MissingOptions < ChefApply::APIError
+      def initialize(*args); super("CHEFAPI001", *args); end
     end
   end
-
-  class MissingOptions < ChefApply::APIError
-    def initialize(*args); super("CHEFAPI001", *args); end
-  end
 end

data/lib/chef_apply/action/generate_temp_cookbook/recipe_lookup.rb

@@ -0,0 +1,124 @@
+#
+# 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"
+require "chef_apply/action/base"
+
+module ChefApply
+  module Action
+    class GenerateTempCookbook
+      # 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
+  end
+end