puppet 0.25.5 → 2.6.0

data/lib/puppet/util/classgen.rb

@@ -1,207 +1,197 @@
 module Puppet
-    class ConstantAlreadyDefined < Error; end
-    class SubclassAlreadyDefined < Error; end
+  class ConstantAlreadyDefined < Error; end
+  class SubclassAlreadyDefined < Error; end
 end
 
 module Puppet::Util::ClassGen
-    include Puppet::Util::MethodHelper
-    include Puppet::Util
-
-    # Create a new subclass.  Valid options are:
-    # * <tt>:array</tt>: An array of existing classes.  If specified, the new
-    #   class is added to this array.
-    # * <tt>:attributes</tt>: A hash of attributes to set before the block is
-    #   evaluated.
-    # * <tt>:block</tt>: The block to evaluate in the context of the class.
-    #   You can also just pass the block normally, but it will still be evaluated
-    #   with <tt>class_eval</tt>.
-    # * <tt>:constant</tt>: What to set the constant as.  Defaults to the
-    #   capitalized name.
-    # * <tt>:hash</tt>: A hash of existing classes.  If specified, the new
-    #   class is added to this hash, and it is also used for overwrite tests.
-    # * <tt>:overwrite</tt>: Whether to overwrite an existing class.
-    # * <tt>:parent</tt>: The parent class for the generated class.  Defaults to
-    #   self.
-    # * <tt>:prefix</tt>: The constant prefix.  Default to nothing; if specified,
-    #   the capitalized name is appended and the result is set as the constant.
-    def genclass(name, options = {}, &block)
-        genthing(name, Class, options, block)
+  include Puppet::Util::MethodHelper
+  include Puppet::Util
+
+  # Create a new subclass.  Valid options are:
+  # * <tt>:array</tt>: An array of existing classes.  If specified, the new
+  #   class is added to this array.
+  # * <tt>:attributes</tt>: A hash of attributes to set before the block is
+  #   evaluated.
+  # * <tt>:block</tt>: The block to evaluate in the context of the class.
+  #   You can also just pass the block normally, but it will still be evaluated
+  #   with <tt>class_eval</tt>.
+  # * <tt>:constant</tt>: What to set the constant as.  Defaults to the
+  #   capitalized name.
+  # * <tt>:hash</tt>: A hash of existing classes.  If specified, the new
+  #   class is added to this hash, and it is also used for overwrite tests.
+  # * <tt>:overwrite</tt>: Whether to overwrite an existing class.
+  # * <tt>:parent</tt>: The parent class for the generated class.  Defaults to
+  #   self.
+  # * <tt>:prefix</tt>: The constant prefix.  Default to nothing; if specified,
+  #   the capitalized name is appended and the result is set as the constant.
+  def genclass(name, options = {}, &block)
+    genthing(name, Class, options, block)
+  end
+
+  # Create a new module.  Valid options are:
+  # * <tt>:array</tt>: An array of existing classes.  If specified, the new
+  #   class is added to this array.
+  # * <tt>:attributes</tt>: A hash of attributes to set before the block is
+  #   evaluated.
+  # * <tt>:block</tt>: The block to evaluate in the context of the class.
+  #   You can also just pass the block normally, but it will still be evaluated
+  #   with <tt>class_eval</tt>.
+  # * <tt>:constant</tt>: What to set the constant as.  Defaults to the
+  #   capitalized name.
+  # * <tt>:hash</tt>: A hash of existing classes.  If specified, the new
+  #   class is added to this hash, and it is also used for overwrite tests.
+  # * <tt>:overwrite</tt>: Whether to overwrite an existing class.
+  # * <tt>:prefix</tt>: The constant prefix.  Default to nothing; if specified,
+  #   the capitalized name is appended and the result is set as the constant.
+  def genmodule(name, options = {}, &block)
+    genthing(name, Module, options, block)
+  end
+
+  # Remove an existing class
+  def rmclass(name, options)
+    options = symbolize_options(options)
+    const = genconst_string(name, options)
+    retval = false
+    if const_defined?(const)
+      remove_const(const)
+      retval = true
     end
 
-    # Create a new module.  Valid options are:
-    # * <tt>:array</tt>: An array of existing classes.  If specified, the new
-    #   class is added to this array.
-    # * <tt>:attributes</tt>: A hash of attributes to set before the block is
-    #   evaluated.
-    # * <tt>:block</tt>: The block to evaluate in the context of the class.
-    #   You can also just pass the block normally, but it will still be evaluated
-    #   with <tt>class_eval</tt>.
-    # * <tt>:constant</tt>: What to set the constant as.  Defaults to the
-    #   capitalized name.
-    # * <tt>:hash</tt>: A hash of existing classes.  If specified, the new
-    #   class is added to this hash, and it is also used for overwrite tests.
-    # * <tt>:overwrite</tt>: Whether to overwrite an existing class.
-    # * <tt>:prefix</tt>: The constant prefix.  Default to nothing; if specified,
-    #   the capitalized name is appended and the result is set as the constant.
-    def genmodule(name, options = {}, &block)
-        genthing(name, Module, options, block)
+    if hash = options[:hash] and hash.include? name
+      hash.delete(name)
+      retval = true
     end
 
-    # Remove an existing class
-    def rmclass(name, options)
-        options = symbolize_options(options)
-        const = genconst_string(name, options)
-        retval = false
-        if const_defined? const
-            remove_const(const)
-            retval = true
-        end
+    # Let them know whether we did actually delete a subclass.
+    retval
+  end
 
-        if hash = options[:hash] and hash.include? name
-            hash.delete(name)
-            retval = true
-        end
+  private
 
-        # Let them know whether we did actually delete a subclass.
-        return retval
+  # Generate the constant to create or remove.
+  def genconst_string(name, options)
+    unless const = options[:constant]
+      prefix = options[:prefix] || ""
+      const = prefix + name2const(name)
     end
 
-    private
+    const
+  end
 
-    # Generate the constant to create or remove.
-    def genconst_string(name, options)
-        unless const = options[:constant]
-            prefix = options[:prefix] || ""
-            const = prefix + name2const(name)
-        end
+  # This does the actual work of creating our class or module.  It's just a
+  # slightly abstract version of genclass.
+  def genthing(name, type, options, block)
+    options = symbolize_options(options)
 
-        return const
-    end
+    name = symbolize(name.to_s.downcase)
 
-    # This does the actual work of creating our class or module.  It's just a
-    # slightly abstract version of genclass.
-    def genthing(name, type, options, block)
-        options = symbolize_options(options)
-
-        name = symbolize(name.to_s.downcase)
-
-        if type == Module
-            #evalmethod = :module_eval
-            evalmethod = :class_eval
-            # Create the class, with the correct name.
-            klass = Module.new do
-                class << self
-                    attr_reader :name
-                end
-                @name = name
-            end
-        else
-            options[:parent] ||= self
-            evalmethod = :class_eval
-            # Create the class, with the correct name.
-            klass = Class.new(options[:parent]) do
-                @name = name
-            end
+    if type == Module
+      #evalmethod = :module_eval
+      evalmethod = :class_eval
+      # Create the class, with the correct name.
+      klass = Module.new do
+        class << self
+          attr_reader :name
         end
+        @name = name
+      end
+    else
+      options[:parent] ||= self
+      evalmethod = :class_eval
+      # Create the class, with the correct name.
+      klass = Class.new(options[:parent]) do
+        @name = name
+      end
+    end
 
-        # Create the constant as appropriation.
-        handleclassconst(klass, name, options)
+    # Create the constant as appropriation.
+    handleclassconst(klass, name, options)
 
-        # Initialize any necessary variables.
-        initclass(klass, options)
+    # Initialize any necessary variables.
+    initclass(klass, options)
 
-        block ||= options[:block]
+    block ||= options[:block]
 
-        # Evaluate the passed block if there is one.  This should usually
-        # define all of the work.
-        if block
-            klass.send(evalmethod, &block)
-        end
+    # Evaluate the passed block if there is one.  This should usually
+    # define all of the work.
+    klass.send(evalmethod, &block) if block
 
-        if klass.respond_to? :postinit
-            klass.postinit
-        end
+    klass.postinit if klass.respond_to? :postinit
 
-        # Store the class in hashes or arrays or whatever.
-        storeclass(klass, name, options)
+    # Store the class in hashes or arrays or whatever.
+    storeclass(klass, name, options)
 
-        return klass
-    end
+    klass
+  end
 
-    # Handle the setting and/or removing of the associated constant.
-    def handleclassconst(klass, name, options)
-        const = genconst_string(name, options)
-
-        if const_defined? const
-            if options[:overwrite]
-                Puppet.info "Redefining %s in %s" % [name, self]
-                remove_const(const)
-            else
-                raise Puppet::ConstantAlreadyDefined,
-                    "Class %s is already defined in %s" % [const, self]
-            end
-        end
-        const_set(const, klass)
+  # Handle the setting and/or removing of the associated constant.
+  def handleclassconst(klass, name, options)
+    const = genconst_string(name, options)
 
-        return const
+    if const_defined?(const)
+      if options[:overwrite]
+        Puppet.info "Redefining #{name} in #{self}"
+        remove_const(const)
+      else
+        raise Puppet::ConstantAlreadyDefined,
+          "Class #{const} is already defined in #{self}"
+      end
     end
+    const_set(const, klass)
 
-    # Perform the initializations on the class.
-    def initclass(klass, options)
-        if klass.respond_to? :initvars
-            klass.initvars
-        end
+    const
+  end
 
-        if attrs = options[:attributes]
-            attrs.each do |param, value|
-                method = param.to_s + "="
-                if klass.respond_to? method
-                    klass.send(method, value)
-                end
-            end
-        end
+  # Perform the initializations on the class.
+  def initclass(klass, options)
+    klass.initvars if klass.respond_to? :initvars
 
-        [:include, :extend].each do |method|
-            if set = options[method]
-                set = [set] unless set.is_a?(Array)
-                set.each do |mod|
-                    klass.send(method, mod)
-                end
-            end
-        end
+    if attrs = options[:attributes]
+      attrs.each do |param, value|
+        method = param.to_s + "="
+        klass.send(method, value) if klass.respond_to? method
+      end
+    end
 
-        if klass.respond_to? :preinit
-            klass.preinit
+    [:include, :extend].each do |method|
+      if set = options[method]
+        set = [set] unless set.is_a?(Array)
+        set.each do |mod|
+          klass.send(method, mod)
         end
+      end
     end
 
-    # Convert our name to a constant.
-    def name2const(name)
-        name.to_s.capitalize
-    end
+    klass.preinit if klass.respond_to? :preinit
+  end
 
-    # Store the class in the appropriate places.
-    def storeclass(klass, klassname, options)
-        if hash = options[:hash]
-            if hash.include? klassname and ! options[:overwrite]
-                raise Puppet::SubclassAlreadyDefined,
-                    "Already a generated class named %s" % klassname
-            end
+  # Convert our name to a constant.
+  def name2const(name)
+    name.to_s.capitalize
+  end
 
-            hash[klassname] = klass
-        end
+  # Store the class in the appropriate places.
+  def storeclass(klass, klassname, options)
+    if hash = options[:hash]
+      if hash.include? klassname and ! options[:overwrite]
+        raise Puppet::SubclassAlreadyDefined,
+          "Already a generated class named #{klassname}"
+      end
+
+      hash[klassname] = klass
+    end
 
-        # If we were told to stick it in a hash, then do so
-        if array = options[:array]
-            if (klass.respond_to? :name and
-                            array.find { |c| c.name == klassname } and
-                            ! options[:overwrite])
-                raise Puppet::SubclassAlreadyDefined,
-                    "Already a generated class named %s" % klassname
-            end
+    # If we were told to stick it in a hash, then do so
+    if array = options[:array]
+      if (klass.respond_to? :name and
+              array.find { |c| c.name == klassname } and
+              ! options[:overwrite])
+        raise Puppet::SubclassAlreadyDefined,
+          "Already a generated class named #{klassname}"
+      end
 
-            array << klass
-        end
+      array << klass
     end
+  end
 end
 

data/lib/puppet/util/command_line.rb

@@ -0,0 +1,95 @@
+module Puppet
+  module Util
+    class CommandLine
+
+            LegacyName = Hash.new{|h,k| k}.update(
+        {
+        'agent'      => 'puppetd',
+        'cert'       => 'puppetca',
+        'doc'        => 'puppetdoc',
+        'filebucket' => 'filebucket',
+        'apply'      => 'puppet',
+        'describe'   => 'pi',
+        'queue'      => 'puppetqd',
+        'resource'   => 'ralsh',
+        'kick'       => 'puppetrun',
+        'master'     => 'puppetmasterd',
+        
+      })
+
+      def initialize( zero = $0, argv = ARGV, stdin = STDIN )
+        @zero  = zero
+        @argv  = argv.dup
+        @stdin = stdin
+
+        @subcommand_name, @args = subcommand_and_args( @zero, @argv, @stdin )
+      end
+
+      attr :subcommand_name
+      attr :args
+
+      def appdir
+        File.join('puppet', 'application')
+      end
+
+      def available_subcommands
+        absolute_appdir = $LOAD_PATH.collect { |x| File.join(x,'puppet','application') }.detect{ |x| File.directory?(x) }
+        Dir[File.join(absolute_appdir, '*.rb')].map{|fn| File.basename(fn, '.rb')}
+      end
+
+      def usage_message
+        usage = "Usage: puppet command <space separated arguments>"
+        available = "Available commands are: #{available_subcommands.sort.join(', ')}"
+        [usage, available].join("\n")
+      end
+
+      def require_application(application)
+        require File.join(appdir, application)
+      end
+
+      def execute
+        if subcommand_name.nil?
+          puts usage_message
+        elsif available_subcommands.include?(subcommand_name) #subcommand
+          require_application subcommand_name
+          Puppet::Application.find(subcommand_name).new(self).run
+        else
+          abort "Error: Unknown command #{subcommand_name}.\n#{usage_message}" unless execute_external_subcommand
+        end
+      end
+
+      def execute_external_subcommand
+          external_command = "puppet-#{subcommand_name}"
+
+          require 'puppet/util'
+          path_to_subcommand = Puppet::Util.binary( external_command )
+          return false unless path_to_subcommand
+
+          system( path_to_subcommand, *args )
+          true
+      end
+
+      def legacy_executable_name
+        LegacyName[ subcommand_name ]
+      end
+
+      private
+
+      def subcommand_and_args( zero, argv, stdin )
+        zero = File.basename(zero, '.rb')
+
+        if zero == 'puppet'
+          case argv.first
+          when nil;              [ stdin.tty? ? nil : "apply", argv] # ttys get usage info
+          when "--help";         [nil,     argv] # help should give you usage, not the help for `puppet apply`
+          when /^-|\.pp$|\.rb$/; ["apply", argv]
+          else [ argv.first, argv[1..-1] ]
+          end
+        else
+          [ zero, argv ]
+        end
+      end
+
+    end
+  end
+end