puppet 3.0.1 → 3.0.2.rc1

data/lib/puppet/util/windows/sid.rb

@@ -0,0 +1,96 @@
+require 'puppet/util/windows'
+
+module Puppet::Util::Windows
+  module SID
+    require 'windows/security'
+    include ::Windows::Security
+
+    require 'windows/memory'
+    include ::Windows::Memory
+
+    require 'windows/msvcrt/string'
+    include ::Windows::MSVCRT::String
+
+    # missing from Windows::Error
+    ERROR_NONE_MAPPED           = 1332
+    ERROR_INVALID_SID_STRUCTURE = 1337
+
+    # Convert an account name, e.g. 'Administrators' into a SID string,
+    # e.g. 'S-1-5-32-544'. The name can be specified as 'Administrators',
+    # 'BUILTIN\Administrators', or 'S-1-5-32-544', and will return the
+    # SID. Returns nil if the account doesn't exist.
+    def name_to_sid(name)
+      # Apparently, we accept a symbol..
+      name = name.to_s if name
+
+      # if it's in SID string form, return it, otherwise, lookup sid
+      is_sid = Win32::Security::SID.string_to_sid(name) rescue nil
+
+      is_sid ? name : Win32::Security::SID.new(name).to_s
+    rescue
+      nil
+    end
+
+    # Convert a SID string, e.g. "S-1-5-32-544" to a name,
+    # e.g. 'BUILTIN\Administrators'. Returns nil if an account
+    # for that SID does not exist.
+    def sid_to_name(value)
+      sid = Win32::Security::SID.new(Win32::Security::SID.string_to_sid(value))
+
+      if sid.domain and sid.domain.length > 0
+        "#{sid.domain}\\#{sid.account}"
+      else
+        sid.account
+      end
+    rescue
+      nil
+    end
+
+    # Convert a SID pointer to a SID string, e.g. "S-1-5-32-544".
+    def sid_ptr_to_string(psid)
+      sid_buf = 0.chr * 256
+      str_ptr = 0.chr * 4
+
+      raise Puppet::Util::Windows::Error.new("Invalid SID") unless IsValidSid(psid)
+
+      raise Puppet::Util::Windows::Error.new("Failed to convert binary SID") unless ConvertSidToStringSid(psid, str_ptr)
+
+      begin
+        strncpy(sid_buf, str_ptr.unpack('L')[0], sid_buf.size - 1)
+        sid_buf[sid_buf.size - 1] = 0.chr
+        return sid_buf.strip
+      ensure
+        LocalFree(str_ptr.unpack('L')[0])
+      end
+    end
+
+    # Convert a SID string, e.g. "S-1-5-32-544" to a pointer (containing the
+    # address of the binary SID structure). The returned value can be used in
+    # Win32 APIs that expect a PSID, e.g. IsValidSid. The account for this
+    # SID may or may not exist.
+    def string_to_sid_ptr(string, &block)
+      sid_buf = 0.chr * 80
+      string_addr = [string].pack('p*').unpack('L')[0]
+
+      raise Puppet::Util::Windows::Error.new("Failed to convert string SID: #{string}") unless ConvertStringSidToSid(string_addr, sid_buf)
+
+      sid_ptr = sid_buf.unpack('L')[0]
+      begin
+        yield sid_ptr
+      ensure
+        LocalFree(sid_ptr)
+      end
+    end
+
+    # Return true if the string is a valid SID, e.g. "S-1-5-32-544", false otherwise.
+    def valid_sid?(string)
+      string_to_sid_ptr(string) { |ptr| true }
+    rescue Puppet::Util::Windows::Error => e
+      if e.code == ERROR_INVALID_SID_STRUCTURE
+        false
+      else
+        raise
+      end
+    end
+  end
+end

data/lib/puppet/version.rb

@@ -6,7 +6,7 @@
 # Raketasks and such to set the version based on the output of `git describe`
 #
 module Puppet
-  PUPPETVERSION = '3.0.1'
+  PUPPETVERSION = '3.0.2-rc1'
 
   def self.version
     @puppet_version || PUPPETVERSION

data/spec/integration/util/windows/security_spec.rb

@@ -15,9 +15,9 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
 
   before :all do
     @sids = {
-      :current_user => Puppet::Util::ADSI.sid_for_account(Sys::Admin.get_login),
-      :admin => Puppet::Util::ADSI.sid_for_account("Administrator"),
-      :guest => Puppet::Util::ADSI.sid_for_account("Guest"),
+      :current_user => Puppet::Util::Windows::Security.name_to_sid(Sys::Admin.get_login),
+      :admin => Puppet::Util::Windows::Security.name_to_sid("Administrator"),
+      :guest => Puppet::Util::Windows::Security.name_to_sid("Guest"),
       :users => Win32::Security::SID::BuiltinUsers,
       :power_users => Win32::Security::SID::PowerUsers,
     }
@@ -371,26 +371,6 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           # end
         end
 
-        describe "#string_to_sid_ptr" do
-          it "should raise an error if an invalid SID is specified" do
-            expect do
-              winsec.string_to_sid_ptr('foobar')
-            end.to raise_error(Puppet::Util::Windows::Error) { |error| error.code.should == 1337 }
-          end
-
-          it "should yield if a block is given" do
-            yielded = nil
-            winsec.string_to_sid_ptr('S-1-1-0') do |sid|
-              yielded = sid
-            end
-            yielded.should_not be_nil
-          end
-
-          it "should allow no block to be specified" do
-            winsec.string_to_sid_ptr('S-1-1-0').should be_true
-          end
-        end
-
         describe "when the parent directory" do
           before :each do
             winsec.set_owner(sids[:current_user], parent)

data/spec/unit/agent_spec.rb

@@ -20,7 +20,7 @@ end
 
 describe Puppet::Agent do
   before do
-    @agent = Puppet::Agent.new(AgentTestClient)
+    @agent = Puppet::Agent.new(AgentTestClient, false)
 
     # So we don't actually try to hit the filesystem.
     @agent.stubs(:lock).yields
@@ -43,7 +43,7 @@ describe Puppet::Agent do
   end
 
   it "should set its client class at initialization" do
-    Puppet::Agent.new("foo").client_class.should == "foo"
+    Puppet::Agent.new("foo", false).client_class.should == "foo"
   end
 
   it "should include the Locker module" do
@@ -181,7 +181,11 @@ describe Puppet::Agent do
 
     describe "when should_fork is true" do
       before do
-        @agent.should_fork = true
+        @agent = Puppet::Agent.new(AgentTestClient, true)
+
+        # So we don't actually try to hit the filesystem.
+        @agent.stubs(:lock).yields
+
         Kernel.stubs(:fork)
         Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => 0)]
         @agent.stubs(:exit)

data/spec/unit/application/agent_spec.rb

@@ -509,6 +509,19 @@ describe Puppet::Application::Agent do
         @puppetd.setup
       end
     end
+
+    describe "when configuring agent for catalog run" do
+      it "should set should_fork as true when running normally" do
+        Puppet::Agent.expects(:new).with(anything, true)
+        @puppetd.setup
+      end
+
+      it "should not set should_fork as false for --onetime" do
+        Puppet[:onetime] = true
+        Puppet::Agent.expects(:new).with(anything, false)
+        @puppetd.setup
+      end
+    end
   end
 
 
@@ -560,11 +573,6 @@ describe Puppet::Application::Agent do
         expect { @puppetd.onetime }.to exit_with 0
       end
 
-      it "should not let the agent fork" do
-        @agent.expects(:should_fork=).with(false)
-        expect { @puppetd.onetime }.to exit_with 0
-      end
-
       it "should let the agent run" do
         @agent.expects(:run).returns(:report)
         expect { @puppetd.onetime }.to exit_with 0

data/spec/unit/daemon_spec.rb

@@ -20,7 +20,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   before do
-    @agent = Puppet::Agent.new(TestClient.new)
+    # Forking agent not needed here
+    @agent = Puppet::Agent.new(TestClient.new, false)
     @daemon = Puppet::Daemon.new
     @daemon.stubs(:close_streams).returns nil
   end

data/spec/unit/hiera/backend/puppet_backend_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
 require 'hiera/backend/puppet_backend'
-
+require 'hiera/scope'
 
 describe Hiera::Backend::Puppet_backend do
+
   before do
     Hiera.stubs(:warn)
     Hiera.stubs(:debug)
@@ -22,33 +23,24 @@ describe Hiera::Backend::Puppet_backend do
 
   describe "#hierarchy" do
     it "should use the configured datasource" do
-      Hiera::Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
-      Hiera::Config.expects("[]").with(:hierarchy)
-
-      ["ntp", "ntp::config"].each do |klass|
-        Hiera::Backend.expects(:parse_string).with(klass, @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns(klass)
-      end
+      with_config(:puppet => {:datasource => "rspec"},
+                  :hierarchy => nil)
 
       @backend.hierarchy(@scope, nil).should == ["rspec::ntp::config", "rspec::ntp", "ntp::config::rspec", "ntp::rspec"]
     end
 
     it "should not include empty class names" do
-      Hiera::Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
-      Hiera::Config.expects("[]").with(:hierarchy).returns(["%{foo}", "common"])
+      with_config(:puppet => {:datasource => "rspec"},
+                  :hierarchy => ["%{foo}", "common"])
 
-      Hiera::Backend.expects(:parse_string).with("common", @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns("common")
-      Hiera::Backend.expects(:parse_string).with("%{foo}", @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns("")
+      @mockscope.expects(:lookupvar).with("foo").returns(nil)
 
       @backend.hierarchy(@scope, nil).should == ["rspec::common", "ntp::config::rspec", "ntp::rspec"]
     end
 
     it "should allow for an override data source" do
-      Hiera::Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
-      Hiera::Config.expects("[]").with(:hierarchy)
-
-      ["ntp", "ntp::config"].each do |klass|
-        Hiera::Backend.expects(:parse_string).with(klass, @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns(klass)
-      end
+      with_config(:puppet => {:datasource => "rspec"},
+                  :hierarchy => nil)
 
       @backend.hierarchy(@scope, "override").should == ["rspec::override", "rspec::ntp::config", "rspec::ntp", "ntp::config::rspec", "ntp::rspec"]
     end
@@ -56,47 +48,61 @@ describe Hiera::Backend::Puppet_backend do
 
   describe "#lookup" do
     it "should attempt to load data from unincluded classes" do
-      Hiera::Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+      with_config(:puppet => {:datasource => "rspec"},
+                  :hierarchy => ["rspec"])
 
       catalog = mock
       catalog.expects(:classes).returns([])
 
-      @scope.expects(:catalog).returns(catalog)
-      @scope.expects(:function_include).with(["rspec"])
-      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec")
+      @mockscope.expects(:catalog).returns(catalog)
+      @mockscope.expects(:function_include).with(["rspec::rspec"])
+      @mockscope.expects(:lookupvar).with("rspec::rspec::key").returns("rspec")
 
-      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec"])
       @backend.lookup("key", @scope, nil, nil).should == "rspec"
     end
 
     it "should not load loaded classes" do
-      Hiera::Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+      with_config(:puppet => {:datasource => "rspec"},
+                  :hierarchy => ["rspec"])
+
       catalog = mock
-      catalog.expects(:classes).returns(["rspec"])
+      catalog.expects(:classes).returns(["rspec::rspec"])
       @mockscope.expects(:catalog).returns(catalog)
       @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec")
+      @mockscope.expects(:lookupvar).with("rspec::rspec::key").returns("rspec")
 
-      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec"])
       @backend.lookup("key", @scope, nil, nil).should == "rspec"
     end
 
     it "should return the first found data" do
-      Hiera::Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+      with_config(:puppet => {:datasource => "rspec"},
+                  :hierarchy => ["override", "rspec"])
+
       catalog = mock
-      catalog.expects(:classes).returns(["rspec", "override"])
+      catalog.expects(:classes).returns(["rspec::override", "override::override"])
       @mockscope.expects(:catalog).returns(catalog)
       @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("override::key").returns("rspec")
-      @mockscope.expects(:lookupvar).with("rspec::key").never
+      @mockscope.expects(:lookupvar).with("rspec::override::key").returns("rspec")
+      @mockscope.expects(:lookupvar).with("rspec::rspec::key").never
 
-      @backend.expects(:hierarchy).with(@scope, "override").returns(["override", "rspec"])
       @backend.lookup("key", @scope, "override", nil).should == "rspec"
     end
 
+    it "should consider a value of false to be a real value" do
+      with_config(:puppet => {:datasource => "rspec"},
+                  :hierarchy => ["override", "rspec"])
+      expected_answer = false
+
+      catalog = mock
+      catalog.expects(:classes).returns(["rspec::override", "override::override"])
+      @mockscope.expects(:catalog).returns(catalog)
+      @mockscope.expects(:lookupvar).with("rspec::override::key").returns(expected_answer)
+      @mockscope.expects(:lookupvar).with("rspec::rspec::key").never
+
+      @backend.lookup("key", @scope, "override", nil).should == expected_answer
+    end
+
     it "should return an array of found data for array searches" do
-      Hiera::Backend.expects(:parse_answer).with("rspec::key", @scope).returns("rspec::key")
-      Hiera::Backend.expects(:parse_answer).with("test::key", @scope).returns("test::key")
       catalog = mock
       catalog.expects(:classes).returns(["rspec", "test"])
       @mockscope.expects(:catalog).returns(catalog)
@@ -108,33 +114,34 @@ describe Hiera::Backend::Puppet_backend do
       @backend.lookup("key", @scope, nil, :array).should == ["rspec::key", "test::key"]
     end
 
-
     it "should return a hash of found data for hash searches" do
-      Hiera::Backend.expects(:parse_answer).with("rspec::key", @scope).returns({'rspec'=>'key'})
-      Hiera::Backend.expects(:parse_answer).with("test::key", @scope).returns({'test'=>'key'})
       catalog = mock
       catalog.expects(:classes).returns(["rspec", "test"])
       @mockscope.expects(:catalog).returns(catalog)
       @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
-      @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
+      @mockscope.expects(:lookupvar).with("rspec::key").returns({'rspec'=>'key'})
+      @mockscope.expects(:lookupvar).with("test::key").returns({'test'=>'key'})
 
       @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
       @backend.lookup("key", @scope, nil, :hash).should == {'rspec'=>'key', 'test'=>'key'}
     end
 
     it "should return a merged hash of found data for hash searches" do
-      Hiera::Backend.expects(:parse_answer).with("rspec::key", @scope).returns({'rspec'=>'key', 'common'=>'rspec'})
-      Hiera::Backend.expects(:parse_answer).with("test::key", @scope).returns({'test'=>'key', 'common'=>'rspec'})
       catalog = mock
       catalog.expects(:classes).returns(["rspec", "test"])
       @mockscope.expects(:catalog).returns(catalog)
       @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
-      @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
+      @mockscope.expects(:lookupvar).with("rspec::key").returns({'rspec'=>'key', 'common'=>'rspec'})
+      @mockscope.expects(:lookupvar).with("test::key").returns({'test'=>'key', 'common'=>'rspec'})
 
       @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
       @backend.lookup("key", @scope, nil, :hash).should == {'rspec'=>'key', 'common'=>'rspec', 'test'=>'key'}
     end
   end
+
+  def with_config(config)
+    config.each do |key, value|
+      Hiera::Config.expects("[]").with(key).returns(value)
+    end
+  end
 end

data/spec/unit/indirector/exec_spec.rb

@@ -15,6 +15,7 @@ describe Puppet::Indirector::Exec do
   end
 
   let(:path) { File.expand_path('/echo') }
+  let(:arguments) { {:failonfail => true, :combine => false } }
 
   before :each do
     @searcher = @exec_class.new
@@ -34,23 +35,24 @@ describe Puppet::Indirector::Exec do
   end
 
   it "should execute the command with the object name as the only argument" do
-    @searcher.expects(:execute).with([path, 'foo'], :combine => false)
+    @searcher.expects(:execute).with([path, 'foo'], arguments)
     @searcher.find(@request)
   end
 
   it "should return the output of the script" do
-    @searcher.expects(:execute).with([path, 'foo'], :combine => false).returns("whatever")
+    @searcher.expects(:execute).with([path, 'foo'], arguments).returns("whatever")
     @searcher.find(@request).should == "whatever"
   end
 
   it "should return nil when the command produces no output" do
-    @searcher.expects(:execute).with([path, 'foo'], :combine => false).returns(nil)
+    @searcher.expects(:execute).with([path, 'foo'], arguments).returns(nil)
     @searcher.find(@request).should be_nil
   end
 
   it "should raise an exception if there's an execution failure" do
-    @searcher.expects(:execute).with([path, 'foo'], :combine => false).raises(Puppet::ExecutionFailure.new("message"))
-
-    lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
+    @searcher.expects(:execute).with([path, 'foo'], arguments).raises(Puppet::ExecutionFailure.new("message"))
+    expect {
+      @searcher.find(@request)
+    }.to raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end
 end

data/spec/unit/parser/functions/hiera_include_spec.rb

@@ -1,19 +1,26 @@
 require 'spec_helper'
+require 'hiera_puppet'
+require 'puppet/parser/functions/hiera_include'
 
 describe 'Puppet::Parser::Functions#hiera_include' do
   let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
 
+  before :each do
+    Puppet[:hiera_config] = PuppetSpec::Files.tmpfile('hiera_config')
+  end
+
   it 'should require a key argument' do
     expect { scope.function_hiera_include([]) }.to raise_error(Puppet::ParseError)
   end
 
   it 'should raise a useful error when nil is returned' do
-    Hiera.any_instance.expects(:lookup).returns(nil)
-    expect { scope.function_hiera_include(["badkey"]) }.to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
+    HieraPuppet.expects(:lookup).returns(nil)
+    expect { scope.function_hiera_include(["badkey"]) }.
+      to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
   end
 
   it 'should use the array resolution_type' do
-    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be :array }.returns([])
-    scope.function_hiera_include(['key'])
+    HieraPuppet.expects(:lookup).with() { |*args| args[4].should be :array }.returns(['someclass'])
+    expect { scope.function_hiera_include(['key']) }.to raise_error Puppet::Error, /Could not find class someclass/
   end
 end