puppet 0.24.9 → 0.25.0

data/lib/puppet/application/filebucket.rb

@@ -0,0 +1,87 @@
+require 'puppet'
+require 'puppet/application'
+require 'puppet/network/client'
+
+Puppet::Application.new(:filebucket) do
+
+    should_not_parse_config
+
+    option("--bucket BUCKET","-b")
+    option("--debug","-d")
+    option("--local","-l")
+    option("--remote","-r")
+    option("--verbose","-v")
+
+    dispatch do
+        ARGV.shift
+    end
+
+    command(:get) do
+        md5 = ARGV.shift
+        out = @client.getfile(md5)
+        print out
+    end
+
+    command(:backup) do
+        ARGV.each do |file|
+            unless FileTest.exists?(file)
+                $stderr.puts "%s: no such file" % file
+                next
+            end
+            unless FileTest.readable?(file)
+                $stderr.puts "%s: cannot read file" % file
+                next
+            end
+            md5 = @client.backup(file)
+            puts "%s: %s" % [file, md5]
+        end
+    end
+
+    command(:restore) do
+        file = ARGV.shift
+        md5 = ARGV.shift
+        @client.restore(file, md5)
+    end
+
+    setup do
+        Puppet::Log.newdestination(:console)
+
+        @client = nil
+        @server = nil
+
+        trap(:INT) do
+            $stderr.puts "Cancelling"
+            exit(1)
+        end
+
+        if options[:debug]
+            Puppet::Log.level = :debug
+        elsif options[:verbose]
+            Puppet::Log.level = :info
+        end
+
+        # Now parse the config
+        Puppet.parse_config
+
+        if Puppet.settings.print_configs?
+                exit(Puppet.settings.print_configs ? 0 : 1)
+        end
+
+        begin
+            if options[:local] or options[:bucket]
+                path = options[:bucket] || Puppet[:bucketdir]
+                @client = Puppet::Network::Client.dipper.new(:Path => path)
+            else
+                require 'puppet/network/handler'
+                @client = Puppet::Network::Client.dipper.new(:Server => Puppet[:server])
+            end
+        rescue => detail
+            $stderr.puts detail
+            if Puppet[:trace]
+                puts detail.backtrace
+            end
+            exit(1)
+        end
+    end
+
+end

data/lib/puppet/application/pi.rb

@@ -0,0 +1,214 @@
+require 'puppet'
+require 'puppet/application'
+
+class Formatter
+
+    def initialize(width)
+        @width = width
+    end
+
+    def wrap(txt, opts)
+        return "" unless txt && !txt.empty?
+        work = (opts[:scrub] ? scrub(txt) : txt)
+        indent = (opts[:indent] ? opts[:indent] : 0)
+        textLen = @width - indent
+        patt = Regexp.new("^(.{0,#{textLen}})[ \n]")
+        prefix = " " * indent
+
+        res = []
+
+        while work.length > textLen
+            if work =~ patt
+                res << $1
+                work.slice!(0, $&.length)
+            else
+                res << work.slice!(0, textLen)
+            end
+        end
+        res << work if work.length.nonzero?
+        return prefix + res.join("\n" + prefix)
+    end
+
+    def header(txt, sep = "-")
+        "\n#{txt}\n" + sep * txt.size
+    end
+
+    private
+
+    def scrub(text)
+        # For text with no carriage returns, there's nothing to do.
+        if text !~ /\n/
+            return text
+        end
+        indent = nil
+
+        # If we can match an indentation, then just remove that same level of
+        # indent from every line.
+        if text =~ /^(\s+)/
+            indent = $1
+            return text.gsub(/^#{indent}/,'')
+        else
+            return text
+        end
+    end
+
+end
+
+class TypeDoc
+
+    def initialize
+        @format = Formatter.new(76)
+        @types = {}
+        Puppet::Type.loadall
+        Puppet::Type.eachtype { |type|
+            next if type.name == :component
+            @types[type.name] = type
+        }
+    end
+
+    def list_types
+        puts "These are the types known to puppet:\n"
+        @types.keys.sort { |a, b|
+            a.to_s <=> b.to_s
+        }.each do |name|
+            type = @types[name]
+            s = type.doc.gsub(/\s+/, " ")
+            n = s.index(".")
+            if n.nil?
+                s = ".. no documentation .."
+            elsif n > 45
+                s = s[0, 45] + " ..."
+            else
+                s = s[0, n]
+            end
+            printf "%-15s - %s\n", name, s
+        end
+    end
+
+    def format_type(name, opts)
+        name = name.to_sym
+        unless @types.has_key?(name)
+            puts "Unknown type #{name}"
+            return
+        end
+        type = @types[name]
+        puts @format.header(name.to_s, "=")
+        puts @format.wrap(type.doc, :indent => 0, :scrub => true) + "\n\n"
+
+        puts @format.header("Parameters")
+        if opts[:parameters]
+            format_attrs(type, [:property, :param])
+        else
+            list_attrs(type, [:property, :param])
+        end
+
+        if opts[:meta]
+            puts @format.header("Meta Parameters")
+            if opts[:parameters]
+                format_attrs(type, [:meta])
+            else
+                list_attrs(type, [:meta])
+            end
+        end
+
+        if type.providers.size > 0
+            puts @format.header("Providers")
+            if opts[:providers]
+                format_providers(type)
+            else
+                list_providers(type)
+            end
+        end
+    end
+
+    # List details about attributes
+    def format_attrs(type, attrs)
+        docs = {}
+        type.allattrs.each do |name|
+            kind = type.attrtype(name)
+            if attrs.include?(kind) && name != :provider
+                docs[name] = type.attrclass(name).doc
+            end
+        end
+
+        docs.sort { |a,b|
+            a[0].to_s <=> b[0].to_s
+        }.each { |name, doc|
+            print "\n- **%s**" % name
+            if type.namevar == name and name != :name
+                puts " (*namevar*)"
+            else
+                puts ""
+            end
+            puts @format.wrap(doc, :indent => 4, :scrub => true)
+        }
+    end
+
+    # List the names of attributes
+    def list_attrs(type, attrs)
+        params = []
+        type.allattrs.each do |name|
+            kind = type.attrtype(name)
+            if attrs.include?(kind) && name != :provider
+                params << name.to_s
+            end
+        end
+        puts @format.wrap(params.sort.join(", "), :indent => 4)
+    end
+
+    def format_providers(type)
+        type.providers.sort { |a,b|
+            a.to_s <=> b.to_s
+        }.each { |prov|
+            puts "\n- **%s**" % prov
+            puts @format.wrap(type.provider(prov).doc,
+                              :indent => 4, :scrub => true)
+        }
+    end
+
+    def list_providers(type)
+        list = type.providers.sort { |a,b|
+            a.to_s <=> b.to_s
+        }.join(", ")
+        puts @format.wrap(list, :indent => 4)
+    end
+
+end
+
+Puppet::Application.new(:pi,"#{$0} [options] [type]") do
+
+    should_not_parse_config
+
+    option("--short", "-s", "Only list parameters without detail") do |arg|
+        options[:parameters] = false
+    end
+
+    option("--providers","-p")
+    option("--list", "-l")
+    option("--meta","-m")
+
+    preinit do
+        options[:parameters] = true
+    end
+
+    command(:main) do
+        doc = TypeDoc.new
+
+        if options[:list]
+            doc.list_types
+        else
+            options[:types].each { |name| doc.format_type(name, options) }
+        end
+    end
+
+    setup do
+        options[:types] = ARGV.dup
+        unless options[:list] || options[:types].size > 0
+            handle_help(nil)
+        end
+        if options[:list] && options[:types].size > 0
+            $stderr.puts "Warning: ignoring types when listing all types"
+        end
+    end
+
+end

data/lib/puppet/application/puppet.rb

@@ -0,0 +1,177 @@
+require 'puppet'
+require 'puppet/application'
+require 'puppet/network/handler'
+require 'puppet/network/client'
+
+Puppet::Application.new(:puppet) do
+
+    should_parse_config
+
+    option("--debug","-d")
+    option("--execute EXECUTE","-e") do |arg|
+        options[:code] = arg
+    end
+    option("--loadclasses","-L")
+    option("--verbose","-v")
+    option("--use-nodes")
+    option("--detailed-exitcodes")
+
+    option("--apply catalog",  "-a catalog") do |arg|
+        options[:catalog] = arg
+    end
+
+    option("--logdest LOGDEST", "-l") do |arg|
+        begin
+            Puppet::Util::Log.newdestination(arg)
+            options[:logset] = true
+        rescue => detail
+            $stderr.puts detail.to_s
+        end
+    end
+
+    dispatch do
+        if options[:catalog]
+            :apply
+        elsif Puppet[:parseonly]
+            :parseonly
+        else
+            :main
+        end
+    end
+
+    command(:apply) do
+        require 'puppet/configurer'
+
+        if options[:catalog] == "-"
+            text = $stdin.read
+        else
+            text = File.read(options[:catalog])
+        end
+
+        begin
+            catalog = JSON.parse(text)
+            unless catalog.is_a?(Puppet::Resource::Catalog)
+                catalog = Puppet::Resource::Catalog.json_create(catalog)
+            end
+        rescue => detail
+            raise Puppet::Error, "Could not deserialize catalog from json: %s" % detail
+        end
+
+        catalog = catalog.to_ral
+
+        configurer = Puppet::Configurer.new
+        configurer.run :catalog => catalog
+    end
+
+    command(:parseonly) do
+        # Set our code or file to use.
+        if options[:code] or ARGV.length == 0
+            Puppet[:code] = options[:code] || STDIN.read
+        else
+            Puppet[:manifest] = ARGV.shift
+        end
+        begin
+            Puppet::Parser::Interpreter.new.parser(Puppet[:environment])
+        rescue => detail
+            Puppet.err detail
+            exit 1
+        end
+        exit 0
+    end
+
+    command(:main) do
+        # Set our code or file to use.
+        if options[:code] or ARGV.length == 0
+            Puppet[:code] = options[:code] || STDIN.read
+        else
+            Puppet[:manifest] = ARGV.shift
+        end
+
+        # Collect our facts.
+        facts = Puppet::Node::Facts.find(Puppet[:certname])
+
+        # Find our Node
+        unless node = Puppet::Node.find(Puppet[:certname])
+            raise "Could not find node %s" % Puppet[:certname]
+        end
+
+        # Merge in the facts.
+        node.merge(facts.values)
+
+        # Allow users to load the classes that puppetd creates.
+        if options[:loadclasses]
+            file = Puppet[:classfile]
+            if FileTest.exists?(file)
+                unless FileTest.readable?(file)
+                    $stderr.puts "%s is not readable" % file
+                    exit(63)
+                end
+                node.classes = File.read(file).split(/[\s\n]+/)
+            end
+        end
+
+        begin
+            # Compile our catalog
+            starttime = Time.now
+            catalog = Puppet::Resource::Catalog.find(node.name, :use_node => node)
+
+            # Translate it to a RAL catalog
+            catalog = catalog.to_ral
+
+            catalog.host_config = true if Puppet[:graph] or Puppet[:report]
+
+            catalog.finalize
+
+            catalog.retrieval_duration = Time.now - starttime
+
+            # And apply it
+            transaction = catalog.apply
+
+            status = 0
+            if not Puppet[:noop] and options[:detailed_exitcodes] then
+                transaction.generate_report
+                status |= 2 if transaction.report.metrics["changes"][:total] > 0
+                status |= 4 if transaction.report.metrics["resources"][:failed] > 0
+            end
+            exit(status)
+        rescue => detail
+            if Puppet[:trace]
+                puts detail.backtrace
+            end
+            if detail.is_a?(XMLRPC::FaultException)
+                $stderr.puts detail.message
+            else
+                $stderr.puts detail
+            end
+            exit(1)
+        end
+    end
+
+    setup do
+        if Puppet.settings.print_configs?
+            exit(Puppet.settings.print_configs ? 0 : 1)
+        end
+
+        # If noop is set, then also enable diffs
+        if Puppet[:noop]
+            Puppet[:show_diff] = true
+        end
+
+        unless options[:logset]
+            Puppet::Util::Log.newdestination(:console)
+        end
+        client = nil
+        server = nil
+
+        trap(:INT) do
+            $stderr.puts "Exiting"
+            exit(1)
+        end
+
+        if options[:debug]
+            Puppet::Util::Log.level = :debug
+        elsif options[:verbose]
+            Puppet::Util::Log.level = :info
+        end
+    end
+end