chef-apply 0.3.3 → 0.4.6

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

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

data/lib/chef_apply/action/install_chef.rb

@@ -16,19 +16,18 @@
 #
 
 require "chef_apply/action/base"
-require "chef_apply/minimum_chef_version"
+require "chef_apply/action/install_chef/minimum_chef_version"
 require "fileutils"
 
 module ChefApply
   module Action
-    class InstallChef < ChefApply::Action::Base
-
+    class InstallChef < Base
       def initialize(opts = { check_only: false })
         super
       end
 
       def perform_action
-        if ChefApply::MinimumChefVersion.check!(target_host, config[:check_only]) == :minimum_version_met
+        if InstallChef::MinimumChefVersion.check!(target_host, config[:check_only]) == :minimum_version_met
           notify(:already_installed)
         else
           perform_local_install
@@ -40,7 +39,7 @@ module ChefApply
       end
 
       def perform_local_install
-        package = lookup_artifact()
+        package = lookup_artifact
         notify(:downloading)
         local_path = download_to_workstation(package.url)
         notify(:uploading)
@@ -54,18 +53,19 @@ module ChefApply
         # TODO BOOTSTRAP - we'll need to implement this for both platforms
         # require "mixlib/install"
         # installer = Mixlib::Install.new({
-        #   platform: "windows",
+        #   platform: "windows",/etc -
         #   product_name: "chef",
         #   channel: :stable,
         #   shell_type: :ps1,
         #   version: "13",
         # })
-        target_host.run_command! installer.install_command
+        # target_host.run_command! installer.install_command
         raise NotImplementedError
       end
 
       def lookup_artifact
         return @artifact_info if @artifact_info
+
         require "mixlib/install"
         c = train_to_mixlib(target_host.platform)
         Mixlib::Install.new(c).artifact_info
@@ -109,7 +109,7 @@ module ChefApply
       end
 
       def upload_to_target(local_path)
-        installer_dir = target_host.temp_dir()
+        installer_dir = target_host.temp_dir
         remote_path = File.join(installer_dir, File.basename(local_path))
         target_host.upload_file(local_path, remote_path)
         remote_path

data/lib/chef_apply/action/install_chef/minimum_chef_version.rb

@@ -0,0 +1,85 @@
+#
+# 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"
+require "chef_apply/action/install_chef/minimum_chef_version"
+
+module ChefApply
+  module Action
+    class InstallChef < Base
+      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
+  end
+end

data/lib/chef_apply/cli.rb

@@ -24,10 +24,6 @@ require "chef-config/logger"
 require "chef_apply/cli/validation"
 require "chef_apply/cli/options"
 require "chef_apply/cli/help"
-require "chef_apply/action/converge_target"
-require "chef_apply/action/generate_local_policy"
-require "chef_apply/action/generate_temp_cookbook"
-require "chef_apply/action/install_chef"
 require "chef_apply/error"
 require "chef_apply/log"
 require "chef_apply/target_host"
@@ -39,6 +35,10 @@ require "chef_apply/ui/terminal/job"
 require "license_acceptance/cli_flags/mixlib_cli"
 require "license_acceptance/acceptor"
 
+require "chef_apply/action/generate_temp_cookbook"
+require "chef_apply/action/generate_local_policy"
+require "chef_apply/action/converge_target"
+
 module ChefApply
   class CLI
     attr_reader :temp_cookbook, :archive_file_location, :target_hosts
@@ -118,9 +118,8 @@ module ChefApply
     rescue OptionParser::InvalidOption => e # from parse_options
       # Using nil here is a bit gross but it prevents usage from printing.
       ove = OptionValidationError.new("CHEFVAL010", nil,
-                                      e.message.split(":")[1].strip, # only want the flag
-                                      format_flags.lines[1..-1].join # remove 'FLAGS:' header
-                                     )
+        e.message.split(":")[1].strip, # only want the flag
+        format_flags.lines[1..-1].join) # remove 'FLAGS:' header
       handle_perform_error(ove)
     rescue => e
       handle_perform_error(e)
@@ -140,8 +139,8 @@ module ChefApply
 
     def resolve_targets(host_spec, opts)
       @target_hosts = TargetResolver.new(host_spec,
-                                         opts.delete(:protocol),
-                                         opts).targets
+        opts.delete(:protocol),
+        opts).targets
     end
 
     def render_cookbook_setup(arguments)
@@ -182,6 +181,7 @@ module ChefApply
     end
 
     def install(target_host, reporter)
+      require "chef_apply/action/install_chef"
       context = TS.install_chef
       reporter.update(context.verifying)
       installer = Action::InstallChef.new(target_host: target_host, check_only: !parsed_options[:install])
@@ -310,6 +310,7 @@ module ChefApply
         # message when there was only one job.
         raise jobs.first.exception
       end
+
       raise ChefApply::MultiJobFailure.new(failed_jobs)
     end
 

data/lib/chef_apply/cli/options.rb

@@ -16,7 +16,6 @@
 #
 
 require "chef_apply/text"
-require "chef_apply/action/install_chef"
 
 # Moving the options into here so the cli.rb file is smaller and easier to read
 # For options that need to be merged back into the global ChefApply::Config object
@@ -68,6 +67,7 @@ module ChefApply
             unless File.exist?(path)
               raise OptionValidationError.new("CHEFVAL001", self, path)
             end
+
             path
           end)
 
@@ -89,7 +89,7 @@ module ChefApply
           long: "--protocol <PROTOCOL>",
           short: "-p",
           description: T.protocol_description(ChefApply::Config::SUPPORTED_PROTOCOLS.join(" "),
-                                              ChefApply::Config.connection.default_protocol),
+            ChefApply::Config.connection.default_protocol),
           default: ChefApply::Config.connection.default_protocol,
           proc: Proc.new { |val| ChefApply::Config.connection.default_protocol(val) }
 

data/lib/chef_apply/cli/validation.rb

@@ -30,6 +30,7 @@ module ChefApply
         if params.size < 2
           raise OptionValidationError.new("CHEFVAL002", self)
         end
+
         if params.size == 2
           # Trying to specify a recipe to run remotely, no properties
           cb = params[1]
@@ -73,7 +74,7 @@ module ChefApply
           value
         when /^\d+$/
           value.to_i
-        when /(^(\d+)(\.)?(\d+)?)|(^(\d+)?(\.)(\d+))/
+        when /^\d+\.\d*$/, /^\d*\.\d+$/
           value.to_f
         when /true/i
           true

data/lib/chef_apply/file_fetcher.rb

@@ -54,7 +54,7 @@ module ChefApply
             @error = true
             raise
           ensure
-            file.close()
+            file.close
             # If any failures occurred, don't risk keeping
             # an incomplete download that we'll see as 'cached'
             if @error

data/lib/chef_apply/log.rb

@@ -24,19 +24,17 @@ module ChefApply
     def self.setup(location, log_level)
       if location.is_a?(String)
         if location.casecmp("stdout") == 0
-          location = $stdout
+          @stream = $stdout
         else
-          location = File.open(location, "w+")
+          @stream = File.open(location, "w+")
         end
       end
-      @location = location
       init(location)
       Log.level = log_level
     end
 
-    def self.location
-      @location
+    def self.stream
+      @stream
     end
-
   end
 end