puppet 3.0.0.rc5 → 3.0.0.rc7

data/{conf → ext}/suse/puppet.spec

@@ -86,7 +86,7 @@ find %{buildroot}%{ruby_sitelibdir} -type f -perm +ugo+x -exec chmod a-x '{}' \;
 %{_initrddir}/puppet
 /var/adm/fillup-templates/sysconfig.puppet
 %config(noreplace) %{_sysconfdir}/puppet/puppet.conf
-%doc CHANGELOG COPYING LICENSE README examples
+%doc COPYING LICENSE README examples
 %config(noreplace) %{_sysconfdir}/logrotate.d/puppet
 %dir %{_sysconfdir}/puppet
 # These need to be owned by puppet so the server can

data/ext/systemd/puppetagent.service

@@ -0,0 +1,13 @@
+[Unit]
+Description=Puppet agent
+Wants=basic.target
+After=basic.target network.target
+
+[Service]
+Type=forking
+PIDFile=/run/puppet/agent.pid
+ExecStartPre=/usr/bin/install -d -o puppet -m 755 /run/puppet
+ExecStart=/usr/bin/puppet agent
+
+[Install]
+WantedBy=multi-user.target

data/ext/systemd/puppetmaster.service

@@ -0,0 +1,13 @@
+[Unit]
+Description=Puppet master
+Wants=basic.target
+After=basic.target network.target
+
+[Service]
+Type=forking
+PIDFile=/run/puppet/master.pid
+ExecStartPre=/usr/bin/install -d -o puppet -m 755 /run/puppet
+ExecStart=/usr/bin/puppet master
+
+[Install]
+WantedBy=multi-user.target

data/ext/windows/service/daemon.bat

@@ -0,0 +1,6 @@
+@echo off
+SETLOCAL
+
+call "%~dp0..\bin\environment.bat" %0 %*
+
+rubyw "%~dp0daemon.rb" %*

data/ext/windows/service/daemon.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'fileutils'
+require 'win32/daemon'
+require 'win32/dir'
+require 'win32/process'
+
+require 'windows/synchronize'
+require 'windows/handle'
+
+class WindowsDaemon < Win32::Daemon
+  include Windows::Synchronize
+  include Windows::Handle
+  include Windows::Process
+
+  LOG_FILE =  File.expand_path(File.join(Dir::COMMON_APPDATA, 'PuppetLabs', 'puppet', 'var', 'log', 'windows.log'))
+  LEVELS = [:debug, :info, :notice, :err]
+  LEVELS.each do |level|
+    define_method("log_#{level}") do |msg|
+      log(msg, level)
+    end
+  end
+
+  def service_init
+    FileUtils.mkdir_p(File.dirname(LOG_FILE))
+  end
+
+  def service_main(*argv)
+    args = argv.join(' ')
+    @loglevel = LEVELS.index(argv.index('--debug') ? :debug : :notice)
+
+    log_notice("Starting service: #{args}")
+
+    while running? do
+      return if state != RUNNING
+
+      log_notice('Service running')
+
+      basedir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      puppet = File.join(basedir, 'bin', 'puppet.bat')
+      unless File.exists?(puppet)
+        log_err("File not found: '#{puppet}'")
+        return
+      end
+
+      log_debug("Using '#{puppet}'")
+      begin
+        runinterval = %x{ "#{puppet}" config print runinterval }.to_i
+        if runinterval == 0
+          runinterval = 1800
+          log_err("Failed to determine runinterval, defaulting to #{runinterval} seconds")
+        end
+      rescue Exception => e
+        log_exception(e)
+        runinterval = 1800
+      end
+
+      pid = Process.create(:command_line => "\"#{puppet}\" agent --onetime #{args}").process_id
+      log_debug("Process created: #{pid}")
+
+      log_debug("Service waiting for #{runinterval} seconds")
+      sleep(runinterval)
+      log_debug('Service resuming')
+    end
+
+    log_notice('Service stopped')
+  rescue Exception => e
+    log_exception(e)
+  end
+
+  def service_stop
+    log_notice('Service stopping')
+    Thread.main.wakeup
+  end
+
+  def log_exception(e)
+    log_err(e.message)
+    log_err(e.backtrace.join("\n"))
+  end
+
+  def log(msg, level)
+    if LEVELS.index(level) >= @loglevel
+      File.open(LOG_FILE, 'a') { |f| f.puts("#{Time.now} Puppet (#{level}): #{msg}") }
+    end
+  end
+end
+
+if __FILE__ == $0
+  WindowsDaemon.mainloop
+end

data/install.rb

@@ -63,16 +63,14 @@ def glob(list)
   g = list.map { |i| Dir.glob(i) }
   g.flatten!
   g.compact!
-  g.reject! { |e| e =~ /\.svn/ }
   g
 end
 
 # Set these values to what you want installed.
 configs = glob(%w{conf/auth.conf})
-sbins = glob(%w{sbin/*})
 bins  = glob(%w{bin/*})
-rdoc  = glob(%w{bin/* sbin/* lib/**/*.rb README README-library CHANGELOG TODO Install}).reject { |e| e=~ /\.(bat|cmd)$/ }
-ri    = glob(%w{bin/*.rb sbin/* lib/**/*.rb}).reject { |e| e=~ /\.(bat|cmd)$/ }
+rdoc  = glob(%w{bin/* lib/**/*.rb README README-library CHANGELOG TODO Install}).reject { |e| e=~ /\.(bat|cmd)$/ }
+ri    = glob(%w{bin/*.rb lib/**/*.rb}).reject { |e| e=~ /\.(bat|cmd)$/ }
 man   = glob(%w{man/man[0-9]/*})
 libs  = glob(%w{lib/**/*.rb lib/**/*.erb lib/**/*.py lib/puppet/util/command_line/*})
 tests = glob(%w{test/**/*.rb})
@@ -89,7 +87,7 @@ def do_configs(configs, target, strip = 'conf/')
   end
 
   if $operatingsystem == 'windows'
-    src_dll = 'conf/windows/eventlog/puppetres.dll'
+    src_dll = 'ext/windows/eventlog/puppetres.dll'
     dst_dll = File.join(InstallOptions.bin_dir, 'puppetres.dll')
     if $haveftools
       File.install(src_dll, dst_dll, 0644, true)
@@ -216,16 +214,16 @@ def prepare_installation
     opts.on('--configdir[=OPTIONAL]', 'Installation directory for config files', 'Default /etc/puppet') do |configdir|
       InstallOptions.configdir = configdir
     end
-    opts.on('--bindir[=OPTIONAL]', 'Installation directory for binaries', 'overrides Config::CONFIG["bindir"]') do |bindir|
+    opts.on('--bindir[=OPTIONAL]', 'Installation directory for binaries', 'overrides RbConfig::CONFIG["bindir"]') do |bindir|
       InstallOptions.bindir = bindir
     end
-    opts.on('--sbindir[=OPTIONAL]', 'Installation directory for system binaries', 'overrides Config::CONFIG["sbindir"]') do |sbindir|
-      InstallOptions.sbindir = sbindir
+    opts.on('--ruby[=OPTIONAL]', 'Ruby interpreter to use with installation', 'overrides ruby used to call install.rb') do |ruby|
+      InstallOptions.ruby = ruby
     end
-    opts.on('--sitelibdir[=OPTIONAL]', 'Installation directory for libraries', 'overrides Config::CONFIG["sitelibdir"]') do |sitelibdir|
+    opts.on('--sitelibdir[=OPTIONAL]', 'Installation directory for libraries', 'overrides RbConfig::CONFIG["sitelibdir"]') do |sitelibdir|
       InstallOptions.sitelibdir = sitelibdir
     end
-    opts.on('--mandir[=OPTIONAL]', 'Installation directory for man pages', 'overrides Config::CONFIG["mandir"]') do |mandir|
+    opts.on('--mandir[=OPTIONAL]', 'Installation directory for man pages', 'overrides RbConfig::CONFIG["mandir"]') do |mandir|
       InstallOptions.mandir = mandir
     end
     opts.on('--quick', 'Performs a quick installation. Only the', 'installation is done.') do |quick|
@@ -249,17 +247,15 @@ def prepare_installation
     opts.parse!
   end
 
-  version = [Config::CONFIG["MAJOR"], Config::CONFIG["MINOR"]].join(".")
-  libdir = File.join(Config::CONFIG["libdir"], "ruby", version)
+  version = [RbConfig::CONFIG["MAJOR"], RbConfig::CONFIG["MINOR"]].join(".")
+  libdir = File.join(RbConfig::CONFIG["libdir"], "ruby", version)
 
-  # Mac OS X 10.5 and higher declare bindir and sbindir as
+  # Mac OS X 10.5 and higher declare bindir
   # /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin
-  # /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/sbin
   # which is not generally where people expect executables to be installed
   # These settings are appropriate defaults for all OS X versions.
   if RUBY_PLATFORM =~ /^universal-darwin[\d\.]+$/
-    Config::CONFIG['bindir'] = "/usr/bin"
-    Config::CONFIG['sbindir'] = "/usr/sbin"
+    RbConfig::CONFIG['bindir'] = "/usr/bin"
   end
 
   if not InstallOptions.configdir.nil?
@@ -279,19 +275,13 @@ def prepare_installation
   if not InstallOptions.bindir.nil?
     bindir = InstallOptions.bindir
   else
-    bindir = Config::CONFIG['bindir']
-  end
-
-  if not InstallOptions.sbindir.nil?
-    sbindir = InstallOptions.sbindir
-  else
-    sbindir = Config::CONFIG['sbindir']
+    bindir = RbConfig::CONFIG['bindir']
   end
 
   if not InstallOptions.sitelibdir.nil?
     sitelibdir = InstallOptions.sitelibdir
   else
-    sitelibdir = Config::CONFIG["sitelibdir"]
+    sitelibdir = RbConfig::CONFIG["sitelibdir"]
     if sitelibdir.nil?
       sitelibdir = $LOAD_PATH.find { |x| x =~ /site_ruby/ }
       if sitelibdir.nil?
@@ -305,7 +295,7 @@ def prepare_installation
   if not InstallOptions.mandir.nil?
     mandir = InstallOptions.mandir
   else
-    mandir = Config::CONFIG['mandir']
+    mandir = RbConfig::CONFIG['mandir']
   end
 
   # This is the new way forward
@@ -321,20 +311,17 @@ def prepare_installation
 
   configdir = join(destdir, configdir)
   bindir = join(destdir, bindir)
-  sbindir = join(destdir, sbindir)
   mandir = join(destdir, mandir)
   sitelibdir = join(destdir, sitelibdir)
 
   FileUtils.makedirs(configdir) if InstallOptions.configs
   FileUtils.makedirs(bindir)
-  FileUtils.makedirs(sbindir)
   FileUtils.makedirs(mandir)
   FileUtils.makedirs(sitelibdir)
 
   InstallOptions.site_dir = sitelibdir
   InstallOptions.config_dir = configdir
   InstallOptions.bin_dir  = bindir
-  InstallOptions.sbin_dir = sbindir
   InstallOptions.lib_dir  = libdir
   InstallOptions.man_dir  = mandir
 end
@@ -398,17 +385,21 @@ rescue LoadError
 end
 
 ##
-# Install file(s) from ./bin to Config::CONFIG['bindir']. Patch it on the way
+# Install file(s) from ./bin to RbConfig::CONFIG['bindir']. Patch it on the way
 # to insert a #! line; on a Unix install, the command is named as expected
 # (e.g., bin/rdoc becomes rdoc); the shebang line handles running it. Under
 # windows, we add an '.rb' extension and let file associations do their stuff.
 def install_binfile(from, op_file, target)
   tmp_file = Tempfile.new('puppet-binfile')
-  ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+
+  if not InstallOptions.ruby.nil?
+    ruby = InstallOptions.ruby
+  else
+    ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  end
 
   File.open(from) do |ip|
     File.open(tmp_file.path, "w") do |op|
-      ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
       op.puts "#!#{ruby}"
       contents = ip.readlines
       contents.shift if contents[0] =~ /^#!/
@@ -456,7 +447,6 @@ prepare_installation
 #build_rdoc(rdoc) if InstallOptions.rdoc
 #build_ri(ri) if InstallOptions.ri
 do_configs(configs, InstallOptions.config_dir) if InstallOptions.configs
-do_bins(sbins, InstallOptions.sbin_dir)
 do_bins(bins, InstallOptions.bin_dir)
 do_libs(libs)
 do_man(man) unless $operatingsystem == "windows"

data/lib/hiera/backend/puppet_backend.rb

@@ -0,0 +1,102 @@
+class Hiera
+  module Backend
+    class Puppet_backend
+      def initialize
+        Hiera.debug("Hiera Puppet backend starting")
+      end
+
+      def hierarchy(scope, override)
+        begin
+          data_class = Config[:puppet][:datasource] || "data"
+        rescue
+          data_class = "data"
+        end
+
+        calling_class = scope.resource.name.to_s.downcase
+        calling_module = calling_class.split("::").first
+
+        hierarchy = Config[:hierarchy] || [calling_class, calling_module]
+
+        hierarchy = [hierarchy].flatten.map do |klass|
+          klass = Backend.parse_string(klass, scope,
+            {
+              "calling_class"  => calling_class,
+              "calling_module" => calling_module
+            }
+          )
+
+          next if klass == ""
+
+          [data_class, klass].join("::")
+        end.compact
+
+        hierarchy << [calling_class, data_class].join("::")
+
+        unless calling_module == calling_class
+          hierarchy << [calling_module, data_class].join("::")
+        end
+
+        hierarchy.insert(0, [data_class, override].join("::")) if override
+
+        hierarchy
+      end
+
+      def lookup(key, scope, order_override, resolution_type)
+        answer = nil
+
+        Hiera.debug("Looking up #{key} in Puppet backend")
+
+        include_class = Puppet::Parser::Functions.function(:include)
+        loaded_classes = scope.catalog.classes
+
+        hierarchy(scope, order_override).each do |klass|
+          Hiera.debug("Looking for data in #{klass}")
+
+          varname = [klass, key].join("::")
+          temp_answer = nil
+
+          unless loaded_classes.include?(klass)
+            begin
+              if scope.respond_to?(:function_include)
+                scope.function_include([klass])
+              else
+                scope.real.function_include([klass])
+              end
+
+              temp_answer = scope[varname]
+              Hiera.debug("Found data in class #{klass}")
+            rescue
+            end
+          else
+            temp_answer = scope[varname]
+          end
+
+          next if temp_answer == :undefined
+
+          if temp_answer
+            # For array resolution we just append to the array whatever we
+            # find, we then go onto the next file and keep adding to the array.
+            #
+            # For priority searches we break after the first found data item.
+            case resolution_type
+            when :array
+              answer ||= []
+              answer << Backend.parse_answer(temp_answer, scope)
+            when :hash
+              answer ||= {}
+              answer = Backend.parse_answer(temp_answer, scope).merge answer
+            else
+              answer = Backend.parse_answer(temp_answer, scope)
+              break
+            end
+          end
+        end
+
+        answer = nil if answer == :undefined
+
+        answer
+      end
+    end
+  end
+end
+

data/lib/hiera/scope.rb

@@ -0,0 +1,42 @@
+class Hiera
+  class Scope
+    attr_reader :real
+
+    def initialize(real)
+      @real = real
+    end
+
+    def [](key)
+      if key == "calling_class"
+        ans = @real.resource.name.to_s.downcase
+      elsif key == "calling_module"
+        ans = @real.resource.name.to_s.downcase.split("::").first
+      else
+        ans = @real.lookupvar(key)
+      end
+
+      # damn you puppet visual basic style variables.
+      return nil if ans == ""
+      return ans
+    end
+
+    def include?(key)
+      return true if ["calling_class", "calling_module"].include?(key)
+
+      return @real.lookupvar(key) != ""
+    end
+
+    def catalog
+      @real.catalog
+    end
+
+    def resource
+      @real.resource
+    end
+
+    def compiler
+      @real.compiler
+    end
+  end
+end
+