puppet 3.0.2 → 3.1.0.rc1

data/lib/puppet/application.rb

@@ -1,8 +1,11 @@
 require 'optparse'
+require 'puppet/util/command_line'
 require 'puppet/util/plugins'
 require 'puppet/util/constant_inflector'
 require 'puppet/error'
 
+module Puppet
+
 # This class handles all the aspects of a Puppet application/executable
 # * setting up options
 # * setting up logs
@@ -116,13 +119,14 @@ require 'puppet/error'
 #          process_member(member)
 #      end
 #  end
-module Puppet
 class Application
   require 'puppet/util'
   include Puppet::Util
 
   DOCPATTERN = ::File.expand_path(::File.dirname(__FILE__) + "/util/command_line/*" )
+  CommandLineArgs = Struct.new(:subcommand_name, :args)
 
+  @loader = Puppet::Util::Autoload.new(self, 'puppet/application')
 
   class << self
     include Puppet::Util
@@ -219,17 +223,32 @@ class Application
       @option_parser_commands
     end
 
-    def find(file_name)
-      # This should probably be using the autoloader, but due to concerns about the fact that
-      #  the autoloader currently considers the modulepath when looking for things to load,
-      #  we're delaying that for now.
+    # @return [Array<String>] the names of available applications
+    # @api public
+    def available_application_names
+      @loader.files_to_load.map do |fn|
+        ::File.basename(fn, '.rb')
+      end.uniq
+    end
+
+    # Finds the class for a given application and loads the class. This does
+    # not create an instance of the application, it only gets a handle to the
+    # class. The code for the application is expected to live in a ruby file
+    # `puppet/application/#{name}.rb` that is available on the `$LOAD_PATH`.
+    #
+    # @param application_name [String] the name of the application to find (eg. "apply").
+    # @return [Class] the Class instance of the application that was found.
+    # @raise [Puppet::Error] if the application class was not found.
+    # @raise [LoadError] if there was a problem loading the application file.
+    # @api public
+    def find(application_name)
       begin
-        require ::File.join('puppet', 'application', file_name.to_s.downcase)
+        require @loader.expand(application_name.to_s.downcase)
       rescue LoadError => e
-        Puppet.log_and_raise(e, "Unable to find application '#{file_name}'.  #{e}")
+        Puppet.log_and_raise(e, "Unable to find application '#{application_name}'. #{e}")
       end
 
-      class_name = Puppet::Util::ConstantInflector.file2constant(file_name.to_s)
+      class_name = Puppet::Util::ConstantInflector.file2constant(application_name.to_s)
 
       clazz = try_load_class(class_name)
 
@@ -239,7 +258,7 @@ class Application
       ####  and then get rid of this stanza in a subsequent release.
       ################################################################
       if (clazz.nil?)
-        class_name = file_name.capitalize
+        class_name = application_name.capitalize
         clazz = try_load_class(class_name)
       end
       ################################################################
@@ -247,7 +266,7 @@ class Application
       ################################################################
 
       if clazz.nil?
-        raise Puppet::Error.new("Unable to load application class '#{class_name}' from file 'puppet/application/#{file_name}.rb'")
+        raise Puppet::Error.new("Unable to load application class '#{class_name}' from file 'puppet/application/#{application_name}.rb'")
       end
 
       return clazz
@@ -315,15 +334,14 @@ class Application
   def preinit
   end
 
-  def initialize(command_line = nil)
-
-    require 'puppet/util/command_line'
-    @command_line = command_line || Puppet::Util::CommandLine.new
+  def initialize(command_line = Puppet::Util::CommandLine.new)
+    @command_line = CommandLineArgs.new(command_line.subcommand_name, command_line.args.dup)
     @options = {}
-
   end
 
-  # This is the main application entry point
+  # Execute the application.
+  # @api public
+  # @return [void]
   def run
 
     # I don't really like the names of these lifecycle phases.  It would be nice to change them to some more meaningful

data/lib/puppet/application/agent.rb

@@ -241,10 +241,10 @@ configuration options can also be generated by running puppet agent with
   debugging or verbosity is enabled.
 
 * --no-client:
-  Do not create a config client. This will cause the daemon to run
-  without ever checking for its configuration automatically, and only
-  makes sense when puppet agent is being run with listen = true in puppet.conf
-  or was started with the `--listen` option.
+  Do not create a config client. This will cause the daemon to start 
+  but not check configuration unless it is triggered with `puppet 
+  kick`. This only makes sense when puppet agent is being run with 
+  listen = true in puppet.conf or was started with the `--listen` option.
 
 * --noop:
   Use 'noop' mode where the daemon runs in a no-op or dry-run mode. This

data/lib/puppet/application/master.rb

@@ -120,18 +120,27 @@ Luke Kanies
 
 COPYRIGHT
 ---------
-Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
+Copyright (c) 2012 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
-  def app_defaults()
-    super.merge :facts_terminus => 'yaml'
+  # Sets up the 'node_cache_terminus' default to use the Write Only Yaml terminus :write_only_yaml.
+  # If this is not wanted, the setting ´node_cache_terminus´ should be set to nil.
+  # @see Puppet::Node::WriteOnlyYaml
+  # @see #setup_node_cache
+  # @see puppet issue 16753
+  #
+  def app_defaults
+    super.merge({
+      :node_cache_terminus => :write_only_yaml,
+      :facts_terminus => 'yaml'
+    })
   end
 
   def preinit
     Signal.trap(:INT) do
-      $stderr.puts "Cancelling startup"
+      $stderr.puts "Canceling startup"
       exit(0)
     end
 
@@ -151,7 +160,6 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
   def compile
     Puppet::Util::Log.newdestination :console
-    raise ArgumentError, "Cannot render compiled catalogs without pson support" unless Puppet.features.pson?
     begin
       unless catalog = Puppet::Resource::Catalog.indirection.find(options[:node])
         raise "Could not compile catalog for #{options[:node]}"
@@ -241,6 +249,16 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
     end
   end
 
+  # Sets up a special node cache "write only yaml" that collects and stores node data in yaml
+  # but never finds or reads anything (this since a real cache causes stale data to be served
+  # in circumstances when the cache can not be cleared).
+  # @see puppet issue 16753
+  # @see Puppet::Node::WriteOnlyYaml
+  # @return [void]
+  def setup_node_cache
+    Puppet::Node.indirection.cache_class = Puppet[:node_cache_terminus]
+  end
+
   def setup
     raise Puppet::Error.new("Puppet master is not supported on Microsoft Windows") if Puppet.features.microsoft_windows?
 
@@ -252,6 +270,8 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     setup_terminuses
 
+    setup_node_cache
+
     setup_ssl
   end
 end

data/lib/puppet/defaults.rb

@@ -1,4 +1,6 @@
 # The majority of Puppet's configuration settings are set in this file.
+
+
 module Puppet
 
   ############################################################################################
@@ -155,12 +157,6 @@ module Puppet
             "all files referenced with `import` statements to exist. This setting was primarily\n" +
             "designed for use with commit hooks for parse-checking.",
     },
-    :authconfig => {
-        :default  => "$confdir/namespaceauth.conf",
-        :desc     => "The configuration file that defines the rights to the different\n" +
-            "namespaces and methods.  This can be used as a coarse-grained\n" +
-            "authorization system for both `puppet agent` and `puppet master`.",
-    },
     :environment => {
         :default  => "production",
         :desc     => "The environment Puppet is running in.  For clients\n" +
@@ -215,6 +211,13 @@ module Puppet
       :default    => "plain",
       :desc       => "Where to find information about nodes.",
     },
+    :node_cache_terminus => {
+      :type       => :terminus,
+      :default    => nil,
+      :desc       => "How to store cached nodes. 
+      Valid values are (none), 'json', 'yaml' or write only yaml ('write_only_yaml').
+      The master application defaults to 'write_only_yaml', all others to none.",
+    },
     :data_binding_terminus => {
       :type    => :terminus,
       :default => "hiera",
@@ -676,7 +679,8 @@ EOT
     :ca_ttl => {
       :default    => "5y",
       :type       => :duration,
-      :desc       => "The default TTL for new certificates. Can be specified as a duration."
+      :desc       => "The default TTL for new certificates. If this setting is set, ca_days is ignored.
+      Can be specified as a duration."
     },
     :ca_md => {
       :default    => "md5",

data/lib/puppet/dsl.rb

@@ -1,7 +1,11 @@
 require 'puppet'
+require 'puppet/dsl/parser'
+require 'puppet/dsl/context'
 
-module Puppet::DSL
+module Puppet
+  # @since 3.1
+  # @status EXPERIMENTALx
+  module DSL
+  end
 end
 
-require 'puppet/dsl/resource_type_api'
-require 'puppet/dsl/resource_api'

data/lib/puppet/dsl/actions.rb

@@ -0,0 +1,283 @@
+require 'puppet/dsl/resource_decorator'
+require 'puppet/dsl/type_reference'
+require 'puppet/util/methodhelper'
+
+module Puppet
+  # @since 3.1 
+  # @status EXPERIMENTAL
+  module DSL
+
+    # {Puppet::DSL::Context} delegates most calls to this class since itself is based
+    # on {BlankSlate}. This simplifies the implementation and makes debugging easier.
+    ##
+    class Actions
+      include Puppet::Util::MethodHelper
+
+      # The filename argument is only used when creating new nodes, definitions
+      # or classes.
+      # @overload initialize()
+      # @overload initialize(filename)
+      #   @param filename [String] required when creating nodes, definitions and classes
+      #
+      def initialize(filename)
+        @filename     = filename
+        @exporting    = false
+        @virtualizing = false
+      end
+
+      # Returns type reference to the given type.
+      # @param name [String] a type name string
+      # @return [TypeReference] to the type of the given name
+      def type_reference(name)
+        TypeReference.new name
+      end
+
+      # Checks whether resource type exists
+      # @param name [String] the name of the type
+      #
+      def is_resource_type?(name)
+        type = Puppet::Resource.canonicalize_type(name)
+        !!(["Node", "Class"].include? type or
+           Puppet::Type.type type or
+           Parser.known_resource_types.find_definition '', type or
+           Parser.known_resource_types.find_hostclass  '', type)
+      end
+
+      # Checks whether Puppet function exists
+      # @param [String] the name of the function
+      def is_function?(name)
+        !!Puppet::Parser::Functions.function(name)
+      end
+
+      # Returns object for accessing params hash (an object that responds to #[]).
+      # All keys will be stringified
+      # @return [#[]] object for looking up parameters
+      #
+      def params
+        Parser.current_scope
+      end
+
+      # Creates a new Puppet node. All arguments have to be passed.
+      # Nesting is the number of nested blocks in Ruby DSL (this can be
+      # basically 0 or 1). Nodes can be only created in the top level scope
+      # 
+      # @param name [String, Regexp] the name match for hostname
+      # @option options [String] :inherits name of parent/super node
+      # @param nesting [Fixnum] 0 if topscope else > 0
+      # @param code [Proc] the body of the created node, evaluated later as Ruby DSL
+      # 
+      # @return [void]
+      # @raise [NoMethodError] if nesting > 0
+      # @raise [ArgumentError] if block is missing
+      #
+      def create_node(name, options, nesting, &code)
+        raise NoMethodError, "nodes can be only created in top level scope" if nesting > 0
+        raise ArgumentError, "no block supplied" if code.nil?
+
+        validate_options [:inherits], options
+
+        name   = name.to_s unless name.is_a? Regexp
+        parent = options[:inherits].to_s if options[:inherits]
+        node = Puppet::Resource::Type.new :node, name, :parent => parent
+        node.ruby_code << Context.new(code, :filename => @filename, :nesting => nesting + 1)
+
+        Parser.known_resource_types.add_node node
+      end
+
+      # Creates a new hostclass. All arguments are required.
+      # Nesting is the number of nested blocks in Ruby DSL (this can be
+      # basically 0 or 1). Classes can be only created in the top level scope.
+      # 
+      # @param name [String] the name of the class
+      # @option options [String] :inherits name of parent/super class
+      # @option options [Hash] :arguments map of parameter name to value
+      # @param nesting [Fixnum] 0 if topscope else > 0
+      # @param code [Proc] the body of the created hostclass, evaluated later as Ruby DSL
+      # 
+      # @return [void]
+      # @raise [NoMethodError] if nesting > 0
+      # @raise [ArgumentError] if block is missing
+      #
+      def create_hostclass(name, options, nesting, &code)
+        raise NoMethodError, "classes can be only created in top level scope" if nesting > 0
+        raise ArgumentError, "no block supplied" if code.nil?
+
+        validate_options [:inherits, :arguments], options
+
+        hostclass = Puppet::Resource::Type.new :hostclass, name.to_s, :arguments => options[:arguments], :parent => options[:inherits].to_s
+        hostclass.ruby_code << Context.new(code, :filename => @filename, :nesting => nesting + 1)
+
+        Parser.known_resource_types.add_hostclass hostclass
+      end
+
+      # Creates a new definition. All arguments are required.
+      # Nesting is the number of nested blocks in Ruby DSL (this can be
+      # basically 0 or 1). Definitions can be only created in the top level scope.
+      # 
+      # @param name [String] the name of the definition
+      # @option options [Hash] :arguments map of parameter name to value
+      # @param nesting [Fixnum] 0 if topscope else > 0
+      # @param code [Proc] the body of the created definition, evaluated later as Ruby DSL
+      # 
+      # @return [void]
+      # @raise [NoMethodError] if nesting > 0
+      # @raise [ArgumentError] if block is missing
+      #
+      def create_definition(name, options, nesting, &code)
+        raise NoMethodError, "definitions can be only created in top level scope" if nesting > 0
+        raise ArgumentError, "no block supplied" if code.nil?
+
+        validate_options [:arguments], options
+
+        definition = Puppet::Resource::Type.new :definition, name.to_s, options
+        definition.ruby_code << Context.new(code, :filename => @filename, :nesting => nesting + 1)
+
+        Parser.known_resource_types.add_definition definition
+      end
+
+      # Creates a resource, all arguments are required.
+      # Type is a Puppet Type of a resource,
+      # Code is a proc that will set additional parameters, can be nil.
+      #
+      # @overload create_resource(type, args, options, {|r| block})
+      # @param type [Symbol] name of resource type
+      # @param args [String, Array<String>] one or several instance names
+      # @param options [Hash] mapping from resource attribute name to value, including mapping of 
+      #   non attribute names :export and :virtual. The set of valid names is determined by the resource type.
+      # @yieldparam r [ResourceDecorator] allows manipulating the created resource
+      # @param block [ruby] evaluated immediately to allow further manipulation of parameters (can be nil)
+      # @return [Puppet::Parser::Resource] the created resource
+      # 
+      # @raise [NoMethodError] if attempt is made to create resource while manifest is imported
+      #
+      def create_resource(type, args, options, code)
+        # when performing type import the scope is nil
+        raise NoMethodError, "resources can't be created in top level scope when importing a manifest" if Parser.current_scope.nil?
+
+        ResourceDecorator.new(options, &code) if code
+
+        Array(args).flatten.map do |name|
+          # Implementation based on
+          # lib/puppet/parser/functions/create_resources.rb
+          #
+          name  = name.to_s
+          scope = Parser.current_scope
+
+          case type
+          when :class
+            klass = Parser.known_resource_types.find_hostclass '', name
+            resource = klass.ensure_in_catalog scope, options
+          else
+            resource = Puppet::Parser::Resource.new type, name,
+              :scope => scope,
+              :source => scope.source
+            options.each do |key, val|
+              resource[key] = get_resource(val)
+            end
+
+            resource.virtual  = true if virtualizing? or options[:virtual]
+            resource.exported = true if exporting?    or options[:export]
+
+            definition = Parser.known_resource_types.definition name
+            definition.instantiate_resource scope, resource if definition
+
+            scope.compiler.add_resource scope, resource
+          end
+          resource
+        end
+      end
+
+      # Calls a puppet function.
+      # It does not validate arguments to the function.
+      #
+      # @example
+      #   call_function :notice, "foo"
+      #
+      # @param name [Symbol] the name of the function
+      # @param *args arguments passed to the called function
+      # @return [Object, void] what the function returns, or void if function does not produce a r-value.
+      #
+      # @raise [NoMethodError] if function is not found
+      #
+      def call_function(name, *args)
+        # when performing type import the scope is nil
+        raise NoMethodError, "functions can't be called in top level scope when importing a manifest" if Parser.current_scope.nil?
+        Parser.current_scope.send name, *args
+      end
+
+
+      # @return [Boolean] flag indicating the _export_ state of a resource
+      attr_accessor :exporting
+      # @return [Boolean] flag indicating the _virtual_ state of a resource
+      attr_accessor :virtualizing
+
+      # Predicate accessor for :exporting
+      # @return [Boolean] true of resource is _export_ state, false otherwise
+      #
+      def exporting?
+        !!@exporting
+      end
+
+      # Predicate accessor for :virtualizing
+      # @return [Boolean] true of resource is _virtual_ state, false otherwise
+      def virtualizing?
+        !!@virtualizing
+      end
+
+      # Exports given resources. Resource references can be used.
+      # @see #get_resource #get_resource for what can be passed as a reference
+      # @param resources [Array<Object>] resources (via reference) to set in _export_ state.
+      # @return [void]
+      #
+      def export_resources(resources)
+        resources.flatten.each do |r|
+          get_resource(r).exported = true
+        end
+      end
+
+      # Virtualizes resources passed in as an array. Resource references can be used.
+      # @param resources [Array<Puppet::Parser::Resource] resources to set in _virtual_ state.
+      # @return [void]
+      #
+      def virtualize_resources(resources)
+        resources.flatten.each do |r|
+          get_resource(r).virtual = true
+        end
+      end
+
+      private
+
+      # Returns a resource for the passed reference
+      # @todo the return of o.to_s is somewhat mysterious and needs an explanation
+      #
+      # @overload get_resource(resource)
+      #   @param resource [Puppet::Resource] a resource
+      # @overload get_resource(reference)
+      #   @param reference [ResourceReference] a reference to a resource
+      # @overload get_resource(name)
+      #   @param name [String] a resource name
+      # @overload get_resource(o)
+      #   @param o [#to_s] ???
+      # @return [Puppet::Resource] the dereferenced resource
+      # @return [String] if reference can not be dereferenced, or not Resource, ResourceReference or String
+      #
+      def get_resource(reference)
+        case reference
+        when Puppet::Resource
+          reference
+        when ResourceReference
+          reference.resource
+        when String
+          # Try to look up a resource by String, if it fails (function returns
+          # nil) just return the string
+          resource = Puppet::DSL::Parser.current_scope.findresource(reference)
+          resource ||= reference
+        else
+          # All values have to be stringified before passing to Puppet Core
+          reference.to_s
+        end
+      end
+
+    end
+  end
+end