chef-apply 0.2.8 → 0.2.13

data/lib/chef_apply/target_host/linux.rb

@@ -0,0 +1,63 @@
+
+
+module ChefApply
+  class TargetHost
+    module Linux
+      def omnibus_manifest_path
+        # TODO - if habitat install on target, this won't work
+        # Note that we can't use File::Join, because that will render for the
+        # CURRENT platform - not the platform of the target.
+        "/opt/chef/version-manifest.json"
+      end
+
+      def mkdir(path)
+        run_command!("mkdir -p #{path}")
+      end
+
+      def chown(path, owner)
+        owner ||= user()
+        run_command!("chown #{owner} '#{path}'")
+        nil
+      end
+
+      def make_temp_dir
+        # We will cache this so that we only
+        @tempdir ||= begin
+          res = run_command!("bash -c '#{MKTEMP_COMMAND}'")
+          res.stdout.chomp.strip
+        end
+      end
+
+      def install_package(target_package_path)
+        install_cmd = case File.extname(target_package_path)
+                      when ".rpm"
+                        "rpm -Uvh #{target_package_path}"
+                      when ".deb"
+                        "dpkg -i #{target_package_path}"
+                      end
+        run_command!(install_cmd)
+        nil
+      end
+
+      def del_file(path)
+        run_command!("rm -rf #{path}")
+      end
+
+      def del_dir(path)
+        del_file(path)
+      end
+
+      def ws_cache_path
+        "/var/chef-workstation"
+      end
+
+      # Nothing to escape in a linux-based path
+      def normalize_path(path)
+        path
+      end
+
+      MKTEMP_COMMAND = "d=$(mktemp -d -p${TMPDIR:-/tmp} chef_XXXXXX); echo $d".freeze
+
+    end
+  end
+end

data/lib/chef_apply/target_host/windows.rb

@@ -0,0 +1,62 @@
+
+module ChefApply
+  class TargetHost
+    module Windows
+      def omnibus_manifest_path
+        # TODO - use a proper method to query the win installation path -
+        #        currently we're assuming the default, but this can be customized
+        #        at install time.
+        #        A working approach is below - but it runs very slowly (~10s) in testing
+        #        on a virtualbox windows vm:
+        #        (over winrm) Get-WmiObject Win32_Product | Where {$_.Name -match 'Chef Client'}
+        # TODO - if habitat install on target, this won't work
+        "c:\\opscode\\chef\\version-manifest.json"
+      end
+
+      def mkdir(path)
+        run_command!("New-Item -ItemType Directory -Force -Path #{path}")
+      end
+
+      def chown(path, owner)
+        # This implementation left intentionally blank.
+        # To date, we have not needed chown functionality on windows;
+        # when/if that changes we'll need to implement it here.
+        nil
+      end
+
+      def make_temp_dir
+        @tmpdir ||= begin
+          res = run_command!(MKTEMP_COMMAND)
+          res.stdout.chomp.strip
+        end
+      end
+
+      def install_package(target_package_path)
+        # While powershell does not mind the mixed path separators \ and /,
+        # 'cmd.exe' definitely does - so we'll make the path cmd-friendly
+        # before running the command
+        cmd = "cmd /c msiexec /package #{target_package_path.tr("/", "\\")} /quiet"
+        run_command!(cmd)
+        nil
+      end
+
+      def del_file(path)
+        run_command!("If (Test-Path #{path}) { Remove-Item -Force -Path #{path} }")
+      end
+
+      def del_dir(path)
+        run_command!("Remove-Item -Recurse -Force –Path #{path}")
+      end
+
+      def ws_cache_path
+        '#{ENV[\'APPDATA\']}/chef-workstation'
+      end
+
+      MKTEMP_COMMAND = "$parent = [System.IO.Path]::GetTempPath();" +
+        "[string] $name = [System.Guid]::NewGuid();" +
+        "$tmp = New-Item -ItemType Directory -Path " +
+        "(Join-Path $parent $name);" +
+        "$tmp.FullName".freeze
+    end
+  end
+end

data/lib/chef_apply/version.rb

@@ -16,5 +16,5 @@
 #
 
 module ChefApply
-  VERSION = "0.2.8".freeze
+  VERSION = "0.2.13".freeze
 end

data/spec/integration/fixtures/chef_help.out

@@ -40,6 +40,7 @@ ARGUMENTS:
                        you to specify which recipe to use from the cookbook.
 
 FLAGS:
+        --chef-license ACCEPTANCE      Accept the license for this product and any contained products ('accept', 'accept-no-persist', or 'accept-silent')
     -c, --config PATH                  Location of config file. Default: $HOME/.chef-workstation/config.toml
         --cookbook-repo-paths PATH     Comma separated list of cookbook repository paths.
     -h, --help                         Show help and usage for `chef-run`

data/spec/unit/action/base_spec.rb

@@ -56,34 +56,4 @@ RSpec.describe ChefApply::Action::Base do
     end
   end
 
-  shared_examples "check path fetching" do
-    [:chef_client, :cache_path, :read_chef_report, :delete_chef_report, :tempdir, :delete_folder].each do |path|
-      it "correctly returns path #{path}" do
-        expect(action.send(path)).to be_a(String)
-      end
-    end
-  end
-
-  describe "when connecting to a windows target" do
-    include_examples "check path fetching"
-
-    it "correctly returns chef run string" do
-      expect(action.run_chef("a", "b", "c")).to eq(
-        "Set-Location -Path a; " \
-        "chef-client -z --config #{File.join("a", "b")} --recipe-url #{File.join("a", "c")} | Out-Null; " \
-        "Set-Location C:/; " \
-        "exit $LASTEXITCODE"
-      )
-    end
-  end
-
-  describe "when connecting to a non-windows target" do
-    let(:family) { "linux" }
-    include_examples "check path fetching"
-
-    it "correctly returns chef run string" do
-      expect(action.run_chef("a", "b", "c")).to eq("bash -c 'cd a; chef-client -z --config a/b --recipe-url a/c'")
-    end
-  end
-
 end

data/spec/unit/action/converge_target_spec.rb

@@ -23,30 +23,33 @@ require "chef_apply/temp_cookbook"
 
 RSpec.describe ChefApply::Action::ConvergeTarget do
   let(:archive) { "archive.tgz" }
+  let(:cache_path) { "/var/chef-workstation" }
+  let(:platform_family) { "windows" }
+  let(:base_os) { :windows }
   let(:target_host) do
-    p = double("platform", family: "windows")
-    instance_double(ChefApply::TargetHost, platform: p)
+    p = double("platform", family: platform_family)
+    double(ChefApply::TargetHost,
+           platform: p, base_os: base_os, ws_cache_path: cache_path)
   end
   let(:local_policy_path) { "/local/policy/path/archive.tgz" }
   let(:opts) { { target_host: target_host, local_policy_path: local_policy_path } }
-  subject(:action) { ChefApply::Action::ConvergeTarget.new(opts) }
+  subject { ChefApply::Action::ConvergeTarget.new(opts) }
 
+  before do
+    allow(target_host).to receive(:normalize_path) { |arg| arg }
+  end
   describe "#create_remote_policy" do
-    let(:remote_folder) { "/tmp/foo" }
-    let(:remote_archive) { File.join(remote_folder, File.basename(archive)) }
-
-    before do
-    end
+    let(:remote_archive) { File.join(cache_path, File.basename(archive)) }
 
     it "pushes it to the remote machine" do
       expect(target_host).to receive(:upload_file).with(local_policy_path, remote_archive)
-      expect(subject.create_remote_policy(local_policy_path, remote_folder)).to eq(remote_archive)
+      expect(subject.create_remote_policy(local_policy_path, cache_path)).to eq(remote_archive)
     end
 
     it "raises an error if the upload fails" do
       expect(target_host).to receive(:upload_file).with(local_policy_path, remote_archive).and_raise("foo")
       err = ChefApply::Action::ConvergeTarget::PolicyUploadFailed
-      expect { subject.create_remote_policy(local_policy_path, remote_folder) }.to raise_error(err)
+      expect { subject.create_remote_policy(local_policy_path, cache_path) }.to raise_error(err)
     end
   end
 
@@ -54,46 +57,78 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
 
     @closed = false # tempfile close indicator
     let(:remote_folder) { "/tmp/foo" }
-    let(:remote_config) { "#{remote_folder}/workstation.rb" }
+    let(:remote_config_path) { "#{remote_folder}/workstation.rb" }
     # TODO - mock this, I think we're leaving things behind in /tmp in test runs.
     let!(:local_tempfile) { Tempfile.new }
 
+    before do
+      allow(Tempfile).to receive(:new).and_return(local_tempfile)
+    end
+
     it "pushes it to the remote machine" do
-      expect(Tempfile).to receive(:new).and_return(local_tempfile)
-      expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config)
-      expect(subject.create_remote_config(remote_folder)).to eq(remote_config)
+      expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
+      expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
       # ensure the tempfile is deleted locally
       expect(local_tempfile.closed?).to eq(true)
     end
 
     it "raises an error if the upload fails" do
-      expect(Tempfile).to receive(:new).and_return(local_tempfile)
-      expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config).and_raise("foo")
+      expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path).and_raise("foo")
       err = ChefApply::Action::ConvergeTarget::ConfigUploadFailed
       expect { subject.create_remote_config(remote_folder) }.to raise_error(err)
       # ensure the tempfile is deleted locally
       expect(local_tempfile.closed?).to eq(true)
     end
 
+    describe "when chef_license is configured" do
+      before do
+        ChefApply::Config.chef.chef_license = "accept-no-persist"
+      end
+
+      after do
+        ChefApply::Config.reset
+      end
+
+      it "creates a config file with chef_license set and quoted" do
+        expect(Tempfile).to receive(:new).and_return(local_tempfile)
+        expect(local_tempfile).to receive(:write).with(<<~EOM
+          local_mode true
+          color false
+          cache_path "#{cache_path}"
+          chef_repo_path "#{cache_path}"
+          require_relative "reporter"
+          reporter = ChefApply::Reporter.new
+          report_handlers << reporter
+          exception_handlers << reporter
+          chef_license "accept-no-persist"
+        EOM
+        )
+        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
+        expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
+        expect(local_tempfile.closed?).to eq(true)
+      end
+    end
+
     describe "when target_level is left default" do
       before do
         ChefApply::Config.reset
       end
+      # TODO - this is a windows config, but we don't set windows?
       it "creates a config file without a specific log_level (leaving default for chef-client)" do
         expect(Tempfile).to receive(:new).and_return(local_tempfile)
         expect(local_tempfile).to receive(:write).with(<<~EOM
           local_mode true
           color false
-          cache_path "\#{ENV['APPDATA']}/chef-workstation"
-          chef_repo_path "\#{ENV['APPDATA']}/chef-workstation"
+          cache_path "#{cache_path}"
+          chef_repo_path "#{cache_path}"
           require_relative "reporter"
           reporter = ChefApply::Reporter.new
           report_handlers << reporter
           exception_handlers << reporter
         EOM
         )
-        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config)
-        expect(subject.create_remote_config(remote_folder)).to eq(remote_config)
+        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
+        expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
         expect(local_tempfile.closed?).to eq(true)
       end
     end
@@ -112,8 +147,8 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
         expect(local_tempfile).to receive(:write).with(<<~EOM
           local_mode true
           color false
-          cache_path "\#{ENV['APPDATA']}/chef-workstation"
-          chef_repo_path "\#{ENV['APPDATA']}/chef-workstation"
+          cache_path "#{cache_path}"
+          chef_repo_path "#{cache_path}"
           require_relative "reporter"
           reporter = ChefApply::Reporter.new
           report_handlers << reporter
@@ -121,8 +156,8 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
           log_level :info
         EOM
         )
-        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config)
-        expect(subject.create_remote_config(remote_folder)).to eq(remote_config)
+        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
+        expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
         expect(local_tempfile.closed?).to eq(true)
       end
     end
@@ -142,8 +177,8 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
         expect(local_tempfile).to receive(:write).with(<<~EOM
           local_mode true
           color false
-          cache_path "\#{ENV['APPDATA']}/chef-workstation"
-          chef_repo_path "\#{ENV['APPDATA']}/chef-workstation"
+          cache_path "#{cache_path}"
+          chef_repo_path "#{cache_path}"
           require_relative "reporter"
           reporter = ChefApply::Reporter.new
           report_handlers << reporter
@@ -154,8 +189,8 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
           data_collector.organization "Chef Workstation"
         EOM
         )
-        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config)
-        expect(subject.create_remote_config(remote_folder)).to eq(remote_config)
+        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
+        expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
       # ensure the tempfile is deleted locally
         expect(local_tempfile.closed?).to eq(true)
       end
@@ -172,16 +207,16 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
         expect(local_tempfile).to receive(:write).with(<<~EOM
           local_mode true
           color false
-          cache_path "\#{ENV['APPDATA']}/chef-workstation"
-          chef_repo_path "\#{ENV['APPDATA']}/chef-workstation"
+          cache_path "#{cache_path}"
+          chef_repo_path "#{cache_path}"
           require_relative "reporter"
           reporter = ChefApply::Reporter.new
           report_handlers << reporter
           exception_handlers << reporter
         EOM
         )
-        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config)
-        expect(subject.create_remote_config(remote_folder)).to eq(remote_config)
+        expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
+        expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
         # ensure the tempfile is deleted locally
         expect(local_tempfile.closed?).to eq(true)
       end
@@ -232,7 +267,7 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
       let!(:cert2) { FileUtils.touch(File.join(certs_dir, "2.pem"))[0] }
 
       it "uploads the local certs" do
-        expect(target_host).to receive(:mkdir).with(remote_tcd)
+        expect(target_host).to receive(:make_directory).with(remote_tcd)
         expect(target_host).to receive(:upload_file).with(cert1, File.join(remote_tcd, File.basename(cert1)))
         expect(target_host).to receive(:upload_file).with(cert2, File.join(remote_tcd, File.basename(cert2)))
         subject.upload_trusted_certs(remote_folder)
@@ -256,21 +291,24 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
     let(:remote_handler) { "#{remote_folder}/reporter.rb" }
     let(:tmpdir) { remote_folder }
     before do
-      expect(target_host).to receive(:mktemp).and_return(tmpdir)
+      expect(target_host).to receive(:temp_dir).and_return(tmpdir)
+      expect(subject).to receive(:create_remote_policy).with(local_policy_path, remote_folder).and_return(remote_archive)
+      expect(subject).to receive(:create_remote_config).with(remote_folder).and_return(remote_config)
+      expect(subject).to receive(:create_remote_handler).with(remote_folder).and_return(remote_handler)
+      expect(subject).to receive(:upload_trusted_certs).with(remote_folder)
     end
     let(:result) { double("command result", exit_status: 0, stdout: "") }
 
     it "runs the converge and reports back success" do
-      expect(action).to receive(:create_remote_policy).with(local_policy_path, remote_folder).and_return(remote_archive)
-      expect(action).to receive(:create_remote_config).with(remote_folder).and_return(remote_config)
-      expect(action).to receive(:create_remote_handler).with(remote_folder).and_return(remote_handler)
-      expect(action).to receive(:upload_trusted_certs).with(remote_folder)
-      expect(target_host).to receive(:run_command).with(/chef-client.+#{archive}/).and_return(result)
-      expect(target_host).to receive(:run_command!)
-        .with("#{subject.delete_folder} #{remote_folder}")
-        .and_return(result)
+      # Note we're only ensuring the command looks the same as #run_chef_cmd - we verify that run_chef_cmd
+      # is correct in its own test elsewhere in this file
+      expect(target_host).to receive(:run_command).with(subject.run_chef_cmd(remote_folder,
+                                                                             "workstation.rb",
+                                                                             "archive.tgz")).and_return result
+      expect(target_host).to receive(:del_dir).with(remote_folder).and_return result
+
       [:running_chef, :success].each do |n|
-        expect(action).to receive(:notify).with(n)
+        expect(subject).to receive(:notify).with(n)
       end
       subject.perform_action
     end
@@ -279,16 +317,12 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
       let(:result) { double("command result", exit_status: 35) }
 
       it "runs the converge and reports back reboot" do
-        expect(action).to receive(:create_remote_policy).with(local_policy_path, remote_folder).and_return(remote_archive)
-        expect(action).to receive(:create_remote_config).with(remote_folder).and_return(remote_config)
-        expect(action).to receive(:create_remote_handler).with(remote_folder).and_return(remote_handler)
-        expect(action).to receive(:upload_trusted_certs).with(remote_folder)
-        expect(target_host).to receive(:run_command).with(/chef-client.+#{archive}/).and_return(result)
-        expect(target_host).to receive(:run_command!)
-          .with("#{subject.delete_folder} #{remote_folder}")
-          .and_return(result)
+        expect(target_host).to receive(:run_command).with(subject.run_chef_cmd(remote_folder,
+                                                                               "workstation.rb",
+                                                                               "archive.tgz")).and_return result
+        expect(target_host).to receive(:del_dir).with(remote_folder).and_return result
         [:running_chef, :reboot].each do |n|
-          expect(action).to receive(:notify).with(n)
+          expect(subject).to receive(:notify).with(n)
         end
         subject.perform_action
       end
@@ -296,7 +330,7 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
 
     context "when command fails" do
       let(:result) { double("command result", exit_status: 1, stdout: "", stderr: "") }
-      let(:report_result) { double("report result", exit_status: 0, stdout: '{ "exception": "thing" }') }
+      let(:report_result) { '{ "exception": "thing" }' }
       let(:exception_mapper) { double("mapper") }
       before do
         expect(ChefApply::Errors::CCRFailureMapper).to receive(:new)
@@ -304,41 +338,64 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
       end
 
       it "reports back failure and reads the remote report" do
-        expect(action).to receive(:create_remote_policy).with(local_policy_path, remote_folder).and_return(remote_archive)
-        expect(action).to receive(:create_remote_config).with(remote_folder).and_return(remote_config)
-        expect(action).to receive(:create_remote_handler).with(remote_folder).and_return(remote_handler)
-        expect(action).to receive(:upload_trusted_certs).with(remote_folder)
-        expect(target_host).to receive(:run_command).with(/chef-client.+#{archive}/).and_return(result)
-        expect(target_host).to receive(:run_command!)
-          .with("#{subject.delete_folder} #{remote_folder}")
+        expect(target_host).to receive(:run_command).with(subject.run_chef_cmd(remote_folder,
+                                                                               "workstation.rb",
+                                                                               "archive.tgz")).and_return result
+        expect(target_host).to receive(:del_dir).with(remote_folder).and_return result
         [:running_chef, :converge_error].each do |n|
-          expect(action).to receive(:notify).with(n)
+          expect(subject).to receive(:notify).with(n)
         end
-        expect(target_host).to receive(:run_command).with(subject.read_chef_report).and_return(report_result)
-        expect(target_host).to receive(:run_command!).with(subject.delete_chef_report)
+        expect(target_host).to receive(:fetch_file_contents).with(subject.chef_report_path).and_return(report_result)
+        expect(target_host).to receive(:del_file).with(subject.chef_report_path)
         expect(exception_mapper).to receive(:raise_mapped_exception!)
         subject.perform_action
       end
 
       context "when remote report cannot be read" do
-        let(:report_result) { double("report result", exit_status: 1, stdout: "", stderr: "") }
+        let(:report_result) { nil }
         it "reports back failure" do
-          expect(action).to receive(:create_remote_policy).with(local_policy_path, remote_folder).and_return(remote_archive)
-          expect(action).to receive(:create_remote_config).with(remote_folder).and_return(remote_config)
-          expect(action).to receive(:create_remote_handler).with(remote_folder).and_return(remote_handler)
-          expect(action).to receive(:upload_trusted_certs).with(remote_folder)
-          expect(target_host).to receive(:run_command).with(/chef-client.+#{archive}/).and_return(result)
-          expect(target_host).to receive(:run_command!)
-            .with("#{subject.delete_folder} #{remote_folder}")
+          expect(target_host).to receive(:run_command).with(subject.run_chef_cmd(remote_folder,
+                                                                                 "workstation.rb",
+                                                                                 "archive.tgz")).and_return result
+          expect(target_host).to receive(:del_dir).with(remote_folder).and_return result
           [:running_chef, :converge_error].each do |n|
-            expect(action).to receive(:notify).with(n)
+            expect(subject).to receive(:notify).with(n)
           end
-          expect(target_host).to receive(:run_command).with(subject.read_chef_report).and_return(report_result)
+          expect(target_host).to receive(:fetch_file_contents).with(subject.chef_report_path).and_return(report_result)
           expect(exception_mapper).to receive(:raise_mapped_exception!)
           subject.perform_action
         end
       end
     end
+
+  end
+
+  context "#run_chef_cmd" do
+    describe "when connecting to a windows target" do
+      let(:base_os) { :windows }
+      # BOOTSTRAP TODO - can't find these examples anywhere - not sure how this was passing
+      # include_examples "check path fetching"
+
+      it "correctly returns chef run string" do
+        expect(subject.run_chef_cmd("a", "b", "c")).to eq(
+          "Set-Location -Path a; " \
+          "chef-client -z --config #{File.join("a", "b")} --recipe-url #{File.join("a", "c")} | Out-Null; " \
+          "Set-Location C:/; " \
+          "exit $LASTEXITCODE"
+        )
+      end
+    end
+
+    describe "when connecting to a non-windows target" do
+      let(:base_os) { :linux }
+      # BOOTSTRAP TODO - can't find these examples anywhere - not sure how this was passing
+      # include_examples "check path fetching"
+
+      it "correctly returns chef run string" do
+        expect(subject.run_chef_cmd("a", "b", "c")).to eq("bash -c 'cd a; chef-client -z --config a/b --recipe-url a/c'")
+      end
+    end
+
   end
 
 end