1 files changed, 72 insertions, 31 deletions

diff --git a/spec/integration/solo/solo_spec.rb b/spec/integration/solo/solo_spec.rb
index 5add4849e9..63525f0081 100644
--- a/spec/integration/solo/solo_spec.rb
+++ b/spec/integration/solo/solo_spec.rb
@@ -4,6 +4,7 @@ require "chef/run_lock"
 require "chef/config"
 require "timeout"
 require "fileutils"
+require "chef/win32/security" if Chef::Platform.windows?
 
 describe "chef-solo" do
   include IntegrationSupport
@@ -15,7 +16,56 @@ describe "chef-solo" do
 
   let(:cookbook_ancient_100_metadata_rb) { cb_metadata("ancient", "1.0.0") }
 
-  let(:chef_solo) { "ruby bin/chef-solo --minimal-ohai" }
+  let(:chef_solo) { "ruby bin/chef-solo --legacy-mode --minimal-ohai" }
+
+  when_the_repository "creates nodes" do
+    let(:nodes_dir) { File.join(@repository_dir, "nodes") }
+    let(:node_file) { Dir[File.join(nodes_dir, "*.json")][0] }
+
+    before do
+      file "config/solo.rb", <<EOM
+chef_repo_path "#{@repository_dir}"
+EOM
+      result = shell_out("ruby bin/chef-solo -c \"#{path_to('config/solo.rb')}\" -l debug", :cwd => chef_dir)
+      result.error!
+    end
+
+    describe "on unix", :unix_only do
+      describe "the nodes directory" do
+        it "has the correct permissions" do
+          expect(File.stat(nodes_dir).mode.to_s(8)[-3..-1]).to eq("700")
+        end
+      end
+
+      describe "the node file" do
+        it "has the correct permissions" do
+          expect(File.stat(node_file).mode.to_s(8)[-4..-1]).to eq("0600")
+        end
+      end
+    end
+
+    describe "on windows", :windows_only do
+      let(:read_mask) { Chef::ReservedNames::Win32::API::Security::GENERIC_READ }
+      let(:write_mask) { Chef::ReservedNames::Win32::API::Security::GENERIC_WRITE }
+      let(:execute_mask) { Chef::ReservedNames::Win32::API::Security::GENERIC_EXECUTE }
+
+      describe "the nodes directory" do
+        it "has the correct permissions" do
+          expect(Chef::ReservedNames::Win32::File.file_access_check(nodes_dir, read_mask)).to be(true)
+          expect(Chef::ReservedNames::Win32::File.file_access_check(nodes_dir, write_mask)).to be(true)
+          expect(Chef::ReservedNames::Win32::File.file_access_check(nodes_dir, execute_mask)).to be(true)
+        end
+      end
+
+      describe "the node file" do
+        it "has the correct permissions" do
+          expect(Chef::ReservedNames::Win32::File.file_access_check(node_file, read_mask)).to be(true)
+          expect(Chef::ReservedNames::Win32::File.file_access_check(node_file, write_mask)).to be(true)
+          expect(Chef::ReservedNames::Win32::File.file_access_check(node_file, execute_mask)).to be(false)
+        end
+      end
+    end
+  end
 
   when_the_repository "has a cookbook with a basic recipe" do
     before do
@@ -112,7 +162,11 @@ EOM
       file "cookbooks/x/recipes/default.rb", <<EOM
 ruby_block "sleeping" do
   block do
-    sleep 10
+    retries = 200
+    while IO.read(Chef::Config[:log_location]) !~ /Chef client .* is running, will wait for it to finish and then run./
+      sleep 0.1
+      raise "we ran out of retries" if ( retries -= 1 ) <= 0
+    end
   end
 end
 EOM
@@ -125,51 +179,38 @@ file_cache_path "#{path_to('config/cache')}"
 EOM
       # We have a timeout protection here so that if due to some bug
       # run_lock gets stuck we can discover it.
-      expect {
+      expect do
         Timeout.timeout(120) do
           chef_dir = File.join(File.dirname(__FILE__), "..", "..", "..")
 
-          # Instantiate the first chef-solo run
-          s1 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \
--l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
+          threads = []
 
-          # Give it some time to progress
-          sleep 5
+          # Instantiate the first chef-solo run
+          threads << Thread.new do
+            s1 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default'  -l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
+            Process.waitpid(s1)
+          end
 
           # Instantiate the second chef-solo run
-          s2 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \
--l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
+          threads << Thread.new do
+            s2 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default'  -l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
+            Process.waitpid(s2)
+          end
 
-          Process.waitpid(s1)
-          Process.waitpid(s2)
+          threads.each(&:join)
         end
-      }.not_to raise_error
+      end.not_to raise_error
 
       # Unfortunately file / directory helpers in integration tests
       # are implemented using before(:each) so we need to do all below
       # checks in one example.
       run_log = File.read(path_to("logs/runs.log"))
 
+      # second run should have a message which indicates it's waiting for the first run
+      expect(run_log).to match(/Chef client .* is running, will wait for it to finish and then run./)
+
       # both of the runs should succeed
       expect(run_log.lines.reject { |l| !l.include? "INFO: Chef Run complete in" }.length).to eq(2)
-
-      # second run should have a message which indicates it's waiting for the first run
-      pid_lines = run_log.lines.reject { |l| !l.include? "Chef-client pid:" }
-      expect(pid_lines.length).to eq(2)
-      pids = pid_lines.map { |l| l.split(" ").last }
-      expect(run_log).to include("Chef client #{pids[0]} is running, will wait for it to finish and then run.")
-
-      # second run should start after first run ends
-      starts = [ ]
-      ends = [ ]
-      run_log.lines.each_with_index do |line, index|
-        if line.include? "Chef-client pid:"
-          starts << index
-        elsif line.include? "INFO: Chef Run complete in"
-          ends << index
-        end
-      end
-      expect(starts[1]).to be > ends[0]
     end
 
   end