puppet 0.9.2 → 0.13.0

data/ext/vim/filetype.vim

@@ -0,0 +1,9 @@
+" detect puppet filetypes
+" $Id: filetype.vim 875 2006-02-07 23:56:16Z luke $
+
+if exists("did_load_filetypes")
+    finish
+endif
+augroup filetypedetect
+    au! BufRead,BufNewFile *.pp     setfiletype puppet
+augroup END

data/ext/vim/puppet.vim

@@ -0,0 +1,87 @@
+" puppet syntax file
+" Filename:     puppet.vim
+" Language:     puppet configuration file 
+" Maintainer:   Luke Kanies <luke@madstop.com>
+" URL:          http://reductivelabs.com/svn/puppet/trunk/ext/vim/puppet.vim
+" Last Change: 
+" Version:      
+"
+" $Id: puppet.vim 875 2006-02-07 23:56:16Z luke $
+
+" Copied from the cfengine, ruby, and perl syntax files
+" For version 5.x: Clear all syntax items
+" For version 6.x: Quit when a syntax file was already loaded
+if version < 600
+  syntax clear
+elseif exists("b:current_syntax")
+  finish
+endif
+
+syn region  puppetDefine        start="^\s*\(class\|define\|site\|node\)" end="{" contains=puppetDefType,puppetDefName,puppetDefArguments
+syn keyword puppetDefType       class define site node inherits contained
+syn keyword puppetInherits      inherits contained
+syn region  puppetDefArguments  start="(" end=")" contains=puppetArgument
+syn match   puppetArgument      "\w\+" contained
+syn match   puppetDefName     "\w\+" contained
+
+syn match   puppetInstance           "\w\+\s*{" contains=puppetTypeBrace,puppetTypeName,puppetTypeDefault
+syn match   puppetTypeBrace       "{" contained
+syn match   puppetTypeName       "[a-z]\w*" contained
+syn match   puppetTypeDefault    "[A-Z]\w*" contained
+
+syn match   puppetParam           "\w\+\s*=>" contains=puppetTypeRArrow,puppetParamName
+syn match   puppetParamRArrow       "=>" contained
+syn match   puppetParamName       "\w\+" contained
+syn match   puppetVariable           "$\w\+"
+syn match   puppetVariable           "${\w\+}"
+syn match   puppetParen           "("
+syn match   puppetParen           ")"
+syn match   puppetBrace           "{"
+syn match   puppetBrace           "}"
+
+syn region  puppetString start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=puppetVariable
+
+syn keyword puppetBoolean    true false 
+syn keyword puppetKeyword    import inherits include
+syn keyword puppetControl    case default 
+
+" comments last overriding everything else
+syn match   puppetComment            "\s*#.*$" contains=puppetTodo
+syn keyword puppetTodo               TODO NOTE FIXME XXX contained
+
+" Define the default highlighting.
+" For version 5.7 and earlier: only when not done already
+" For version 5.8 and later: only when an item doesn't have highlighting yet
+if version >= 508 || !exists("did_puppet_syn_inits")
+  if version < 508
+    let did_puppet_syn_inits = 1
+    command -nargs=+ HiLink hi link <args>
+  else
+    command -nargs=+ HiLink hi def link <args>
+  endif
+
+  HiLink puppetVariable             Identifier
+  HiLink puppetBoolean              Boolean
+  HiLink puppetType                 Identifier
+  HiLink puppetDefault              Identifier
+  HiLink puppetKeyword              Define
+  HiLink puppetTypeDefs             Define
+  HiLink puppetComment              Comment
+  HiLink puppetString               String
+  HiLink puppetTodo                 Todo
+"  HiLink puppetBrace                Delimiter
+"  HiLink puppetTypeBrace            Delimiter
+"  HiLink puppetParen                Delimiter
+  HiLink puppetDelimiter            Delimiter
+  HiLink puppetControl              Statement
+  HiLink puppetDefType              Define
+  HiLink puppetDefName              Type
+  HiLink puppetTypeName             Statement
+  HiLink puppetTypeDefault          Type
+  HiLink puppetParamName            Identifier
+  HiLink puppetArgument             Identifier
+
+  delcommand HiLink
+endif
+
+let b:current_syntax = "puppet"

data/install.rb

@@ -30,27 +30,37 @@
 # 5) Install all library files ending in .rb from lib/ into Ruby's
 #    site_lib/version directory.
 #
-# $Id: install.rb 576 2005-08-23 16:09:14Z luke $
+# $Id: install.rb 779 2006-01-05 20:36:01Z luke $
 #++
 
 require 'rbconfig'
 require 'find'
 require 'fileutils'
-require 'rdoc/rdoc'
+require 'ftools' # apparently on some system ftools doesn't get loaded
 require 'optparse'
 require 'ostruct'
 
+begin
+    require 'rdoc/rdoc'
+    $haverdoc = true
+rescue LoadError
+    puts "Missing rdoc; skipping documentation"
+    $haverdoc = false
+end
+
+PREREQS = %w{openssl facter xmlrpc/client xmlrpc/server cgi}
+
 InstallOptions = OpenStruct.new
 
 def glob(list)
-  g = list.map { |i| Dir.glob(i) }
-  g.flatten!
-  g.compact!
-  g.reject! { |e| e =~ /\.svn/ }
-  g
+    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.
+# Set these values to what you want installed.
 bins  = glob(%w{bin/**/*})
 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)$/ }
@@ -74,15 +84,32 @@ def do_libs(libs, strip = 'lib/')
   end
 end
 
+# Verify that all of the prereqs are installed
+def check_prereqs
+    PREREQS.each { |pre|
+        begin
+            require pre
+        rescue LoadError
+            puts "Could not load %s; cannot install" % pre
+        end
+    }
+end
+
 ##
 # Prepare the file installation.
 #
 def prepare_installation
-  InstallOptions.rdoc  = true
-  if RUBY_PLATFORM == "i386-mswin32"
-    InstallOptions.ri  = false
+  # Only try to do docs if we're sure they have rdoc
+  if $haverdoc
+      InstallOptions.rdoc  = true
+      if RUBY_PLATFORM == "i386-mswin32"
+        InstallOptions.ri  = false
+      else
+        InstallOptions.ri  = true
+      end
   else
-    InstallOptions.ri  = true
+      InstallOptions.rdoc  = false
+      InstallOptions.ri  = false
   end
   InstallOptions.tests = true
 
@@ -153,25 +180,30 @@ end
 # Build the rdoc documentation. Also, try to build the RI documentation.
 #
 def build_rdoc(files)
-  r = RDoc::RDoc.new
-  r.document(["--main", "README", "--title", "Puppet -- Site Configuration Management",
-              "--line-numbers"] + files)
-
-rescue RDoc::RDocError => e
-  $stderr.puts e.message
-rescue Exception => e
-  $stderr.puts "Couldn't build RDoc documentation\n#{e.message}"
+    return unless $haverdoc
+    begin
+        r = RDoc::RDoc.new
+        r.document(["--main", "README", "--title",
+            "Puppet -- Site Configuration Management", "--line-numbers"] + files)
+    rescue RDoc::RDocError => e
+        $stderr.puts e.message
+    rescue Exception => e
+        $stderr.puts "Couldn't build RDoc documentation\n#{e.message}"
+    end
 end
 
 def build_ri(files)
-  ri = RDoc::RDoc.new
-  #ri.document (["--ri-site", "--merge"] + files)
-  ri.document(["--ri-site"] + files)
-rescue RDoc::RDocError => e
-  $stderr.puts e.message
-rescue Exception => e
-  $stderr.puts "Couldn't build Ri documentation\n#{e.message}"
-  $stderr.puts "Continuing with install..."
+    return unless $haverdoc
+    begin
+        ri = RDoc::RDoc.new
+        #ri.document(["--ri-site", "--merge"] + files)
+        ri.document(["--ri-site"] + files)
+    rescue RDoc::RDocError => e
+        $stderr.puts e.message
+    rescue Exception => e
+        $stderr.puts "Couldn't build Ri documentation\n#{e.message}"
+        $stderr.puts "Continuing with install..."
+    end
 end
 
 def run_tests(test_list)
@@ -261,10 +293,11 @@ goto done
 :done
 EOS
 
+check_prereqs
 prepare_installation
 
 run_tests(tests) if InstallOptions.tests
-build_rdoc(rdoc) if InstallOptions.rdoc
-build_ri(ri) if InstallOptions.ri
+#build_rdoc(rdoc) if InstallOptions.rdoc
+#build_ri(ri) if InstallOptions.ri
 do_bins(bins, Config::CONFIG['bindir'])
 do_libs(libs)

data/lib/puppet.rb

@@ -1,5 +1,8 @@
 require 'singleton'
+require 'puppet/event-loop'
 require 'puppet/log'
+require 'puppet/config'
+require 'puppet/util'
 
 # see the bottom of the file for further inclusions
 
@@ -11,7 +14,7 @@ require 'puppet/log'
 #
 # it's also a place to find top-level commands like 'debug'
 module Puppet
-    PUPPETVERSION="0.9.1"
+    PUPPETVERSION = '0.13.0'
 
     def Puppet.version
         return PUPPETVERSION
@@ -19,10 +22,18 @@ module Puppet
 
     class Error < RuntimeError
         attr_accessor :stack, :line, :file
+        attr_writer :backtrace
+
+        def backtrace
+            if defined? @backtrace
+                return @backtrace
+            else
+                return super
+            end
+        end
+
         def initialize(message)
             @message = message
-
-            @stack = caller
         end
 
         def to_s
@@ -47,8 +58,12 @@ module Puppet
 
     class DevError < Error; end
 
+    def self.name
+        $0.gsub(/.+#{File::SEPARATOR}/,'')
+    end
+
     # the hash that determines how our system behaves
-    @@config = Hash.new(false)
+    @@config = Puppet::Config.new
 
     # define helper messages for each of the message levels
     Puppet::Log.eachlevel { |level|
@@ -68,50 +83,103 @@ module Puppet
     # XXX this isn't actually working right now
     alias :error :err
 
-    @defaults = {
-        :rrddir         => [:puppetvar,      "rrd"],
-        :logdir         => [:puppetvar,      "log"],
-        :bucketdir      => [:puppetvar,      "bucket"],
-        :statedir       => [:puppetvar,      "state"],
-
-        # then the files},
-        :manifestdir    => [:puppetconf,     "manifests"],
-        :manifest       => [:manifestdir,    "site.pp"],
-        :localconfig    => [:puppetconf,     "localconfig.ma"],
-        :logfile        => [:logdir,         "puppet.log"],
-        :httplogfile    => [:logdir,         "http.log"],
-        :masterlog      => [:logdir,         "puppetmaster.log"],
-        :masterhttplog  => [:logdir,         "masterhttp.log"],
-        :checksumfile   => [:statedir,       "checksums"],
-        :ssldir         => [:puppetconf,     "ssl"],
-
-        # and finally the simple answers,
-        :server         => "puppet",
-        :rrdgraph       => false,
-        :noop           => false,
-        :parseonly      => false,
-        :puppetport     => 8139,
-        :masterport     => 8140,
-    }
-    if Process.uid == 0
-        @defaults[:puppetconf] = "/etc/puppet"
-        @defaults[:puppetvar] = "/var/puppet"
-    else
-        @defaults[:puppetconf] = File.expand_path("~/.puppet")
-        @defaults[:puppetvar] = File.expand_path("~/.puppet/var")
+    # Store a new default value.
+    def self.setdefaults(section, *arrays)
+        start = Time.now
+        @@config.setdefaults(section, *arrays)
     end
 
-    def self.clear
-        @@config = Hash.new(false)
+    # If we're running the standalone puppet process as a non-root user,
+    # use basedirs that are in the user's home directory.
+    conf = nil
+    var = nil
+    if self.name == "puppet" and Process.uid != 0
+        conf = File.expand_path("~/.puppet")
+        var = File.expand_path("~/.puppet/var")
+    else
+        # Else, use system-wide directories.
+        conf = "/etc/puppet"
+        var = "/var/puppet"
     end
+    self.setdefaults("puppet",
+        [:confdir, conf, "The main Puppet configuration directory."],
+        [:vardir, var, "Where Puppet stores dynamic and growing data."]
+    )
+
+    # Define the config default.
+    self.setdefaults(self.name,
+        [:config, "$confdir/#{self.name}.conf",
+            "The configuration file for #{self.name}."]
+    )
+
+    self.setdefaults("puppet",
+        [:logdir,          "$vardir/log",
+            "The Puppet log directory."],
+        [:bucketdir,       "$vardir/bucket",
+            "Where FileBucket files are stored."],
+        [:statedir,        "$vardir/state",
+            "The directory where Puppet state is stored.  Generally, this
+            directory can be removed without causing harm (although it might
+            result in spurious service restarts)."],
+        [:rundir,          "$vardir/run", "Where Puppet PID files are kept."],
+        [:statefile,       "$statedir/state.yaml",
+            "Where puppetd and puppetmasterd store state associated with the running
+            configuration.  In the case of puppetmasterd, this file reflects the
+            state discovered through interacting with clients."],
+        [:ssldir,          "$confdir/ssl", "Where SSL certificates are kept."],
+        [:genconfig,        false,
+            "Whether to just print a configuration to stdout and exit.  Only makes
+            sense when used interactively.  Takes into account arguments specified
+            on the CLI."],
+        [:genmanifest,        false,
+            "Whether to just print a manifest to stdout and exit.  Only makes
+            sense when used interactively.  Takes into account arguments specified
+            on the CLI."]
+    )
+    self.setdefaults("puppetmasterd",
+        [:manifestdir,     "$confdir/manifests",
+            "Where puppetmasterd looks for its manifests."],
+        [:manifest,        "$manifestdir/site.pp",
+            "The entry-point manifest for puppetmasterd."],
+        [:masterlog,       "$logdir/puppetmaster.log",
+            "Where puppetmasterd logs.  This is generally not used, since syslog
+            is the default log destination."],
+        [:masterhttplog,   "$logdir/masterhttp.log",
+            "Where the puppetmasterd web server logs."],
+        [:masterport,      8140, "Which port puppetmasterd listens on."],
+        [:parseonly,       false, "Just check the syntax of the manifests."]
+    )
+
+    self.setdefaults("puppetd",
+        [:localconfig,     "$confdir/localconfig",
+            "Where puppetd caches the local configuration.  An extension reflecting
+            the cache format is added automatically."],
+        [:classfile,       "$confdir/classes.txt",
+            "The file in which puppetd stores a list of the classes associated
+            with the retrieved configuratiion."],
+        [:puppetdlog,         "$logdir/puppetd.log",
+            "The log file for puppetd.  This is generally not used."],
+        [:httplog,     "$logdir/http.log", "Where the puppetd web server logs."],
+        [:server,          "puppet",
+            "The server to which server puppetd should connect"],
+        [:user,            "puppet", "The user puppetmasterd should run as."],
+        [:group,           "puppet", "The group puppetmasterd should run as."],
+        [:ignoreschedules, false,
+            "Boolean; whether puppetd should ignore schedules.  This is useful
+            for initial puppetd runs."],
+        [:puppetport,      8139, "Which port puppetd listens on."],
+        [:noop,            false, "Whether puppetd should be run in noop mode."],
+        [:runinterval,     1800, # 30 minutes
+            "How often puppetd applies the client configuration; in seconds"]
+    )
+    self.setdefaults("metrics",
+        [:rrddir,          "$vardir/rrd",
+            "The directory where RRD database files are stored."],
+        [:rrdgraph,        false, "Whether RRD information should be graphed."]
+    )
 
 	# configuration parameter access and stuff
 	def self.[](param)
-        if param.is_a?(String)
-            param = param.intern
-        elsif ! param.is_a?(Symbol)
-            raise ArgumentError, "Invalid parameter type %s" % param.class
-        end
         case param
         when :debug:
             if Puppet::Log.level == :debug
@@ -119,104 +187,113 @@ module Puppet
             else
                 return false
             end
-        when :loglevel:
-            return Puppet::Log.level
         else
-            # allow manual override
-            if @@config.include?(param)
-                return @@config[param]
-            else
-                if @defaults.include?(param)
-                    default = @defaults[param]
-                    if default.is_a?(Proc)
-                        return default.call()
-                    elsif default.is_a?(Array)
-                        return File.join(self[default[0]], default[1])
-                    else
-                        return default
-                    end
-                else
-                    raise ArgumentError, "Invalid parameter %s" % param
-                end
-            end
+            return @@config[param]
         end
 	end
 
 	# configuration parameter access and stuff
 	def self.[]=(param,value)
-        case param
-        when :debug:
-            if value
-                Puppet::Log.level=(:debug)
-            else
-                Puppet::Log.level=(:notice)
-            end
-        when :loglevel:
-            Puppet::Log.level=(value)
-        when :logdest:
-            Puppet::Log.newdestination(value)
-        else
-            @@config[param] = value
-        end
+        @@config[param] = value
+#        case param
+#        when :debug:
+#            if value
+#                Puppet::Log.level=(:debug)
+#            else
+#                Puppet::Log.level=(:notice)
+#            end
+#        when :loglevel:
+#            Puppet::Log.level=(value)
+#        when :logdest:
+#            Puppet::Log.newdestination(value)
+#        else
+#            @@config[param] = value
+#        end
 	end
 
-    def self.asuser(user)
-        # FIXME this should use our user object, since it already knows how
-        # to find users and such
-        require 'etc'
+    def self.clear
+        @@config.clear
+    end
 
-        begin
-            obj = Etc.getpwnam(user)
-        rescue ArgumentError
-            raise Puppet::Error, "User %s not found"
+    def self.debug=(value)
+        if value
+            Puppet::Log.level=(:debug)
+        else
+            Puppet::Log.level=(:notice)
         end
+    end
 
-        uid = obj.uid
+    def self.config
+        @@config
+    end
 
-        olduid = nil
-        if Process.uid != uid
-            olduid = Process.uid
-            Process.euid = uid
+    def self.genconfig
+        if Puppet[:genconfig]
+            puts Puppet.config.to_config
+            exit(0)
         end
+    end
 
-        retval = yield
-
-
-        if olduid
-            Process.euid = olduid
+    def self.genmanifest
+        if Puppet[:genmanifest]
+            puts Puppet.config.to_manifest
+            exit(0)
         end
-
-        return retval
     end
 
-    def self.setdefault(param,value)
-        if value.is_a?(Array) 
-            if value[0].is_a?(Symbol) 
-                unless @defaults.include?(value[0])
-                    raise ArgumentError, "Unknown basedir %s for param %s" %
-                        [value[0], param]
-                end
-            else
-                raise ArgumentError, "Invalid default %s for param %s" %
-                    [value.inspect, param]
-            end
-
-            unless value[1].is_a?(String)
-                raise ArgumentError, "Invalid default %s for param %s" %
-                    [value.inspect, param]
-            end
-
-            unless value.length == 2
-                raise ArgumentError, "Invalid default %s for param %s" %
-                    [value.inspect, param]
-            end
+    # Start our event loop.  This blocks, waiting for someone, somewhere,
+    # to generate events of some kind.
+    def self.start
+        #Puppet.info "Starting loop"
+        EventLoop.current.run
+    end
 
-            @defaults[param] = value
-        else
-            @defaults[param] = value
+    # Create the timer that our different objects (uh, mostly the client)
+    # check.
+    def self.timer
+        unless defined? @timer
+            #Puppet.info "Interval is %s" % Puppet[:runinterval]
+            #@timer = EventLoop::Timer.new(:interval => Puppet[:runinterval])
+            @timer = EventLoop::Timer.new(
+                :interval => Puppet[:runinterval],
+                :tolerance => 1,
+                :start? => true
+            )
+            EventLoop.current.monitor_timer @timer
         end
+        @timer
     end
 
+    # Store a new default value.
+#    def self.setdefaults(section, hash)
+#        @@config.setdefaults(section, hash)
+#        if value.is_a?(Array) 
+#            if value[0].is_a?(Symbol) 
+#                unless @defaults.include?(value[0])
+#                    raise ArgumentError, "Unknown basedir %s for param %s" %
+#                        [value[0], param]
+#                end
+#            else
+#                raise ArgumentError, "Invalid default %s for param %s" %
+#                    [value.inspect, param]
+#            end
+#
+#            unless value[1].is_a?(String)
+#                raise ArgumentError, "Invalid default %s for param %s" %
+#                    [value.inspect, param]
+#            end
+#
+#            unless value.length == 2
+#                raise ArgumentError, "Invalid default %s for param %s" %
+#                    [value.inspect, param]
+#            end
+#
+#            @defaults[param] = value
+#        else
+#            @defaults[param] = value
+#        end
+#    end
+
     # XXX this should all be done using puppet objects, not using
     # normal mkdir
     def self.recmkdir(dir,mode = 0755)
@@ -228,20 +305,37 @@ module Puppet
             tmp.split(File::SEPARATOR).each { |dir|
                 path.push dir
                 if ! FileTest.exist?(File.join(path))
-                    Dir.mkdir(File.join(path), mode)
+                    begin
+                        Dir.mkdir(File.join(path), mode)
+                    rescue Errno::EACCES => detail
+                        Puppet.err detail.to_s
+                        return false
+                    rescue => detail
+                        Puppet.err "Could not create %s: %s" % [path, detail.to_s]
+                        return false
+                    end
                 elsif FileTest.directory?(File.join(path))
                     next
                 else FileTest.exist?(File.join(path))
-                    raise "Cannot create %s: basedir %s is a file" %
+                    raise Puppet::Error, "Cannot create %s: basedir %s is a file" %
                         [dir, File.join(path)]
                 end
             }
             return true
         end
     end
+
+    # Create a new type.  Just proxy to the Type class.
+    def self.newtype(name, parent = nil, &block)
+        Puppet::Type.newtype(name, parent, &block)
+    end
+
+    # Retrieve a type by name.  Just proxy to the Type class.
+    def self.type(name)
+        Puppet::Type.type(name)
+    end
 end
 
-require 'puppet/util'
 require 'puppet/server'
 require 'puppet/type'
 require 'puppet/storage'