puppet 2.6.18 → 2.7.1

data/lib/puppet/interface/option.rb

@@ -0,0 +1,108 @@
+require 'puppet/interface'
+
+class Puppet::Interface::Option
+  include Puppet::Interface::TinyDocs
+
+  def initialize(parent, *declaration, &block)
+    @parent   = parent
+    @optparse = []
+
+    # Collect and sort the arguments in the declaration.
+    dups = {}
+    declaration.each do |item|
+      if item.is_a? String and item.to_s =~ /^-/ then
+        unless item =~ /^-[a-z]\b/ or item =~ /^--[^-]/ then
+          raise ArgumentError, "#{item.inspect}: long options need two dashes (--)"
+        end
+        @optparse << item
+
+        # Duplicate checking...
+        name = optparse_to_name(item)
+        if dup = dups[name] then
+          raise ArgumentError, "#{item.inspect}: duplicates existing alias #{dup.inspect} in #{@parent}"
+        else
+          dups[name] = item
+        end
+      else
+        raise ArgumentError, "#{item.inspect} is not valid for an option argument"
+      end
+    end
+
+    if @optparse.empty? then
+      raise ArgumentError, "No option declarations found while building"
+    end
+
+    # Now, infer the name from the options; we prefer the first long option as
+    # the name, rather than just the first option.
+    @name = optparse_to_name(@optparse.find do |a| a =~ /^--/ end || @optparse.first)
+    @aliases = @optparse.map { |o| optparse_to_name(o) }
+
+    # Do we take an argument?  If so, are we consistent about it, because
+    # incoherence here makes our life super-difficult, and we can more easily
+    # relax this rule later if we find a valid use case for it. --daniel 2011-03-30
+    @argument = @optparse.any? { |o| o =~ /[ =]/ }
+    if @argument and not @optparse.all? { |o| o =~ /[ =]/ } then
+      raise ArgumentError, "Option #{@name} is inconsistent about taking an argument"
+    end
+
+    # Is our argument optional?  The rules about consistency apply here, also,
+    # just like they do to taking arguments at all. --daniel 2011-03-30
+    @optional_argument = @optparse.any? { |o| o=~/[ =]\[/ }
+    @optional_argument and raise ArgumentError, "Options with optional arguments are not supported"
+    if @optional_argument and not @optparse.all? { |o| o=~/[ =]\[/ } then
+      raise ArgumentError, "Option #{@name} is inconsistent about the argument being optional"
+    end
+  end
+
+  # to_s and optparse_to_name are roughly mirrored, because they are used to
+  # transform options to name symbols, and vice-versa.  This isn't a full
+  # bidirectional transformation though. --daniel 2011-04-07
+  def to_s
+    @name.to_s.tr('_', '-')
+  end
+
+  def optparse_to_name(declaration)
+    unless found = declaration.match(/^-+(?:\[no-\])?([^ =]+)/) then
+      raise ArgumentError, "Can't find a name in the declaration #{declaration.inspect}"
+    end
+    name = found.captures.first.tr('-', '_')
+    raise "#{name.inspect} is an invalid option name" unless name.to_s =~ /^[a-z]\w*$/
+    name.to_sym
+  end
+
+
+  def takes_argument?
+    !!@argument
+  end
+  def optional_argument?
+    !!@optional_argument
+  end
+  def required?
+    !!@required
+  end
+
+  attr_reader   :parent, :name, :aliases, :optparse
+  attr_accessor :required
+
+  attr_accessor :before_action
+  def before_action=(proc)
+    proc.is_a? Proc or raise ArgumentError, "before action hook for #{self} is a #{proc.class.name.inspect}, not a proc"
+    @before_action =
+      @parent.__send__(:__add_method, __decoration_name(:before), proc)
+  end
+
+  attr_accessor :after_action
+  def after_action=(proc)
+    proc.is_a? Proc or raise ArgumentError, "after action hook for #{self} is a #{proc.class.name.inspect}, not a proc"
+    @after_action =
+      @parent.__send__(:__add_method, __decoration_name(:after), proc)
+  end
+
+  def __decoration_name(type)
+    if @parent.is_a? Puppet::Interface::Action then
+      :"option #{name} from #{parent.name} #{type} decoration"
+    else
+      :"option #{name} #{type} decoration"
+    end
+  end
+end

data/lib/puppet/interface/option_builder.rb

@@ -0,0 +1,54 @@
+require 'puppet/interface/option'
+
+class Puppet::Interface::OptionBuilder
+  attr_reader :option
+
+  def self.build(face, *declaration, &block)
+    new(face, *declaration, &block).option
+  end
+
+  private
+  def initialize(face, *declaration, &block)
+    @face   = face
+    @option = Puppet::Interface::Option.new(face, *declaration)
+    instance_eval(&block) if block_given?
+    @option
+  end
+
+  # Metaprogram the simple DSL from the option class.
+  Puppet::Interface::Option.instance_methods.grep(/=$/).each do |setter|
+    next if setter =~ /^=/
+    dsl = setter.to_s.chomp('=')
+
+    unless private_method_defined? dsl
+      define_method(dsl) do |value| @option.send(setter, value) end
+    end
+  end
+
+  # Override some methods that deal in blocks, not objects.
+  def before_action(&block)
+    block or raise ArgumentError, "#{@option} before_action requires a block"
+    if @option.before_action
+      raise ArgumentError, "#{@option} already has a before_action set"
+    end
+    unless block.arity == 3 then
+      raise ArgumentError, "before_action takes three arguments, action, args, and options"
+    end
+    @option.before_action = block
+  end
+
+  def after_action(&block)
+    block or raise ArgumentError, "#{@option} after_action requires a block"
+    if @option.after_action
+      raise ArgumentError, "#{@option} already has a after_action set"
+    end
+    unless block.arity == 3 then
+      raise ArgumentError, "after_action takes three arguments, action, args, and options"
+    end
+    @option.after_action = block
+  end
+
+  def required(value = true)
+    @option.required = value
+  end
+end

data/lib/puppet/interface/option_manager.rb

@@ -0,0 +1,67 @@
+require 'puppet/interface/option_builder'
+
+module Puppet::Interface::OptionManager
+  # Declare that this app can take a specific option, and provide
+  # the code to do so.
+  def option(*declaration, &block)
+    add_option Puppet::Interface::OptionBuilder.build(self, *declaration, &block)
+  end
+
+  def add_option(option)
+    # @options collects the added options in the order they're declared.
+    # @options_hash collects the options keyed by alias for quick lookups.
+    @options      ||= []
+    @options_hash ||= {}
+
+    option.aliases.each do |name|
+      if conflict = get_option(name) then
+        raise ArgumentError, "Option #{option} conflicts with existing option #{conflict}"
+      end
+
+      actions.each do |action|
+        action = get_action(action)
+        if conflict = action.get_option(name) then
+          raise ArgumentError, "Option #{option} conflicts with existing option #{conflict} on #{action}"
+        end
+      end
+    end
+
+    option.aliases.each do |name|
+      @options << name
+      @options_hash[name] = option
+    end
+
+    return option
+  end
+
+  def options
+    result = (@options ||= [])
+
+    if self.is_a?(Class) and superclass.respond_to?(:options)
+      result = superclass.options + result
+    elsif self.class.respond_to?(:options)
+      result = self.class.options + result
+    end
+
+    return result
+  end
+
+  def get_option(name, with_inherited_options = true)
+    @options_hash ||= {}
+
+    result = @options_hash[name.to_sym]
+    if result.nil? and with_inherited_options then
+      if self.is_a?(Class) and superclass.respond_to?(:get_option)
+        result = superclass.get_option(name)
+      elsif self.class.respond_to?(:get_option)
+        result = self.class.get_option(name)
+      end
+    end
+
+    return result
+  end
+
+  def option?(name)
+    options.include? name.to_sym
+  end
+end

data/lib/puppet/metatype/manager.rb

@@ -61,9 +61,10 @@ module Manager
 
     # Then create the class.
 
-    klass = genclass(
-      name,
+          klass = genclass(
+        name,
       :parent => (parent || Puppet::Type),
+        
       :overwrite => true,
       :hash => @types,
       :attributes => options,
@@ -86,11 +87,14 @@ module Manager
 
     # Now set up autoload any providers that might exist for this type.
 
-    klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")
+          klass.providerloader = Puppet::Util::Autoload.new(
+        klass,
+        
+      "puppet/provider/#{klass.name.to_s}"
+    )
 
-    # We have to load everything so that we can figure out the default provider.
+    # We have to load everything so that we can figure out the default type.
     klass.providerloader.loadall
-    klass.providify unless klass.providers.empty?
 
     klass
   end
@@ -99,7 +103,11 @@ module Manager
   def rmtype(name)
     # Then create the class.
 
-    klass = rmclass(name, :hash => @types)
+          klass = rmclass(
+        name,
+        
+      :hash => @types
+    )
 
     singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
   end
@@ -124,7 +132,12 @@ module Manager
   # Create a loader for Puppet types.
   def typeloader
     unless defined?(@typeloader)
-      @typeloader = Puppet::Util::Autoload.new(self, "puppet/type", :wrap => false)
+
+            @typeloader = Puppet::Util::Autoload.new(
+        self,
+        
+        "puppet/type", :wrap => false
+      )
     end
 
     @typeloader

data/lib/puppet/module.rb

@@ -138,7 +138,7 @@ class Puppet::Module
 
   # Find this module in the modulepath.
   def path
-    environment.modulepath.collect { |path| File.join(path, name) }.find { |d| FileTest.exist?(d) }
+    environment.modulepath.collect { |path| File.join(path, name) }.find { |d| FileTest.directory?(d) }
   end
 
   # Find all plugin directories.  This is used by the Plugins fileserving mount.

data/lib/puppet/network/client.rb

@@ -0,0 +1,179 @@
+# the available clients
+
+require 'puppet'
+require 'puppet/network/xmlrpc/client'
+require 'puppet/util/subclass_loader'
+require 'puppet/util/methodhelper'
+require 'puppet/sslcertificates/support'
+
+require 'puppet/network/handler'
+
+require 'net/http'
+
+# Some versions of ruby don't have this method defined, which basically causes
+# us to never use ssl.  Yay.
+class Net::HTTP
+  def use_ssl?
+    if defined?(@use_ssl)
+      @use_ssl
+    else
+      false
+    end
+  end
+
+  # JJM: This is a "backport" of sorts to older ruby versions which
+  # do not have this accessor.  See #896 for more information.
+  attr_accessor :enable_post_connection_check unless Net::HTTP.method_defined? "enable_post_connection_check"
+end
+
+# The base class for all of the clients.  Many clients just directly
+# call methods, but some of them need to do some extra work or
+# provide a different interface.
+class Puppet::Network::Client
+  Client = self
+  include Puppet::Util
+  extend Puppet::Util::SubclassLoader
+  include Puppet::Util::MethodHelper
+
+  # This handles reading in the key and such-like.
+  include Puppet::SSLCertificates::Support
+
+  attr_accessor :schedule, :lastrun, :local, :stopping
+
+  attr_reader :driver
+
+  # Set up subclass loading
+  handle_subclasses :client, "puppet/network/client"
+
+  # Determine what clients look for when being passed an object for local
+  # client/server stuff.  E.g., you could call Client::CA.new(:CA => ca).
+  def self.drivername
+    @drivername ||= self.name
+  end
+
+  # Figure out the handler for our client.
+  def self.handler
+    @handler ||= Puppet::Network::Handler.handler(self.name)
+  end
+
+  # The class that handles xmlrpc interaction for us.
+  def self.xmlrpc_client
+    @xmlrpc_client ||= Puppet::Network::XMLRPCClient.handler_class(self.handler)
+  end
+
+  # Create our client.
+  def initialize(hash)
+    # to whom do we connect?
+    @server = nil
+
+    if hash.include?(:Cache)
+      @cache = hash[:Cache]
+    else
+      @cache = true
+    end
+
+    driverparam = self.class.drivername
+    if hash.include?(:Server)
+      args = {:Server => hash[:Server]}
+      @server = hash[:Server]
+      args[:Port] = hash[:Port] || Puppet[:masterport]
+
+      @driver = self.class.xmlrpc_client.new(args)
+
+      self.read_cert
+
+      # We have to start the HTTP connection manually before we start
+      # sending it requests or keep-alive won't work.  Note that with #1010,
+      # we don't currently actually want keep-alive.
+      @driver.start if @driver.respond_to? :start and Puppet::Network::HttpPool.keep_alive?
+
+      @local = false
+    elsif hash.include?(driverparam)
+      @driver = hash[driverparam]
+      if @driver == true
+        @driver = self.class.handler.new
+      end
+      @local = true
+    else
+      raise Puppet::Network::ClientError, "#{self.class} must be passed a Server or #{driverparam}"
+    end
+  end
+
+  # Are we a local client?
+  def local?
+    if @local
+      true
+    else
+      false
+    end
+  end
+
+  # Make sure we set the driver up when we read the cert in.
+  def recycle_connection
+    @driver.recycle_connection if @driver.respond_to?(:recycle_connection)
+  end
+
+  # A wrapper method to run and then store the last run time
+  def runnow
+    if self.stopping
+      Puppet.notice "In shutdown progress; skipping run"
+      return
+    end
+    begin
+      self.run
+      self.lastrun = Time.now.to_i
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Could not run #{self.class}: #{detail}"
+    end
+  end
+
+  def run
+    raise Puppet::DevError, "Client type #{self.class} did not override run"
+  end
+
+  def scheduled?
+    if sched = self.schedule
+      return sched.match?(self.lastrun)
+    else
+      return true
+    end
+  end
+
+  def shutdown
+    if self.stopping
+      Puppet.notice "Already in shutdown"
+    else
+      self.stopping = true
+      Puppet::Util::Storage.store if self.respond_to? :running? and self.running?
+      rmpidfile
+    end
+  end
+
+  # Start listening for events.  We're pretty much just listening for
+  # timer events here.
+  def start
+    # Create our timer.  Puppet will handle observing it and such.
+
+          timer = Puppet.newtimer(
+                
+      :interval => Puppet[:runinterval],
+      :tolerance => 1,
+        
+      :start? => true
+    ) do
+      begin
+        self.runnow if self.scheduled?
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err "Could not run client; got otherwise uncaught exception: #{detail}"
+      end
+    end
+
+    # Run once before we start following the timer
+    self.runnow
+  end
+
+  require 'puppet/network/client/proxy'
+end
+