puppet 0.25.5 → 2.6.0

data/lib/puppet/application/ralsh.rb

@@ -1,152 +0,0 @@
-require 'puppet'
-require 'puppet/application'
-require 'facter'
-
-Puppet::Application.new(:ralsh) do
-
-    should_not_parse_config
-
-    attr_accessor :host, :extra_params
-
-    preinit do
-        @extra_params = []
-        @host = nil
-        Facter.loadfacts
-    end
-
-    option("--debug","-d")
-    option("--verbose","-v")
-    option("--edit","-e")
-
-    option("--host HOST","-H") do |arg|
-        @host = arg
-    end
-
-    option("--types", "-t") do |arg|
-        types = []
-        Puppet::Type.loadall
-        Puppet::Type.eachtype do |t|
-            next if t.name == :component
-            types << t.name.to_s
-        end
-        puts types.sort
-        exit
-    end
-
-    option("--param PARAM", "-p") do |arg|
-        @extra_params << arg.to_sym
-    end
-
-    command(:main) do
-        type = ARGV.shift or raise "You must specify the type to display"
-        typeobj = Puppet::Type.type(type) or raise "Could not find type #{type}"
-        name = ARGV.shift
-        params = {}
-        ARGV.each do |setting|
-            if setting =~ /^(\w+)=(.+)$/
-                params[$1] = $2
-            else
-                raise "Invalid parameter setting %s" % setting
-            end
-        end
-
-        if options[:edit] and @host
-            raise "You cannot edit a remote host"
-        end
-
-        properties = typeobj.properties.collect { |s| s.name }
-
-        format = proc {|trans|
-            trans.dup.collect do |param, value|
-                if value.nil? or value.to_s.empty?
-                    trans.delete(param)
-                elsif value.to_s == "absent" and param.to_s != "ensure"
-                    trans.delete(param)
-                end
-
-                unless properties.include?(param) or @extra_params.include?(param)
-                    trans.delete(param)
-                end
-            end
-            trans.to_manifest
-        }
-
-        text = if @host
-            client = Puppet::Network::Client.resource.new(:Server => @host, :Port => Puppet[:puppetport])
-            unless client.read_cert
-                raise "client.read_cert failed"
-            end
-            begin
-                # They asked for a single resource.
-                if name
-                    transbucket = [client.describe(type, name)]
-                else
-                    # Else, list the whole thing out.
-                    transbucket = client.instances(type)
-                end
-            rescue Puppet::Network::XMLRPCClientError => exc
-                raise "client.list(#{type}) failed: #{exc.message}"
-            end
-            transbucket.sort { |a,b| a.name <=> b.name }.collect(&format)
-        else
-            if name
-                obj = typeobj.instances.find { |o| o.name == name } || typeobj.new(:name => name, :check => properties)
-                vals = obj.retrieve
-
-                unless params.empty?
-                    params.each do |param, value|
-                        obj[param] = value
-                    end
-                    catalog = Puppet::Resource::Catalog.new
-                    catalog.add_resource obj
-                    begin
-                        catalog.apply
-                    rescue => detail
-                        if Puppet[:trace]
-                            puts detail.backtrace
-                        end
-                    end
-
-                end
-                [format.call(obj.to_trans(true))]
-            else
-                typeobj.instances.collect do |obj|
-                    next if ARGV.length > 0 and ! ARGV.include? obj.name
-                    trans = obj.to_trans(true)
-                    format.call(trans)
-                end
-            end
-        end.compact.join("\n")
-
-        if options[:edit]
-            file = "/tmp/x2puppet-#{Process.pid}.pp"
-            begin
-                File.open(file, "w") do |f|
-                    f.puts text
-                end
-                ENV["EDITOR"] ||= "vi"
-                system(ENV["EDITOR"], file)
-                system("puppet -v " + file)
-            ensure
-                #if FileTest.exists? file
-                #    File.unlink(file)
-                #end
-            end
-        else
-            puts text
-        end
-    end
-
-    setup do
-        Puppet::Util::Log.newdestination(:console)
-
-        # Now parse the config
-        Puppet.parse_config
-
-        if options[:debug]
-            Puppet::Util::Log.level = :debug
-        elsif options[:verbose]
-            Puppet::Util::Log.level = :info
-        end
-    end
-end

data/lib/puppet/checksum.rb

@@ -1,57 +0,0 @@
-#
-#  Created by Luke Kanies on 2007-9-22.
-#  Copyright (c) 2007. All rights reserved.
-
-require 'puppet'
-require 'puppet/util/checksums'
-require 'puppet/indirector'
-
-# A checksum class to model translating checksums to file paths.  This
-# is the new filebucket.
-class Puppet::Checksum
-    include Puppet::Util::Checksums
-
-    extend Puppet::Indirector
-
-    indirects :checksum
-
-    attr_reader :algorithm, :content
-
-    def algorithm=(value)
-        unless respond_to?(value)
-            raise ArgumentError, "Checksum algorithm %s is not supported" % value
-        end
-        value = value.intern if value.is_a?(String)
-        @algorithm = value
-        # Reset the checksum so it's forced to be recalculated.
-        @checksum = nil
-    end
-
-    # Calculate (if necessary) and return the checksum
-    def checksum
-        unless @checksum
-            @checksum = send(algorithm, content)
-        end
-        @checksum
-    end
-
-    def initialize(content, algorithm = "md5")
-        raise ArgumentError.new("You must specify the content") unless content
-
-        @content = content
-
-        # Init to avoid warnings.
-        @checksum = nil
-
-        self.algorithm = algorithm
-    end
-
-    # This is here so the Indirector::File terminus works correctly.
-    def name
-        checksum
-    end
-
-    def to_s
-        "Checksum<{%s}%s>" % [algorithm, checksum]
-    end
-end

data/lib/puppet/indirector/checksum/file.rb

@@ -1,33 +0,0 @@
-require 'puppet/checksum'
-require 'puppet/indirector/file'
-
-class Puppet::Checksum::File < Puppet::Indirector::File
-    desc "Store files in a directory set based on their checksums."
-
-    def initialize
-        Puppet.settings.use(:filebucket)
-    end
-
-    def path(checksum)
-        path = []
-        path << Puppet[:bucketdir]                              # Start with the base directory
-        path << checksum[0..7].split("").join(File::SEPARATOR)  # Add sets of directories based on the checksum
-        path << checksum                                        # And the full checksum name itself
-        path << "contents"                                      # And the actual file name
-
-        path.join(File::SEPARATOR)
-    end
-
-    def save(request)
-        path = File.dirname(path(request.key))
-
-        # Make the directories if necessary.
-        unless FileTest.directory?(path)
-            Puppet::Util.withumask(0007) do
-                FileUtils.mkdir_p(path)
-            end
-        end
-
-        super
-    end
-end

data/lib/puppet/indirector/runner/rest.rb

@@ -1,7 +0,0 @@
-require 'puppet/agent'
-require 'puppet/agent/runner'
-require 'puppet/indirector/rest'
-
-class Puppet::Agent::Runner::Rest < Puppet::Indirector::REST
-    desc "Trigger Agent runs via REST."
-end

data/lib/puppet/network/client/dipper.rb

@@ -1,85 +0,0 @@
-# The client class for filebuckets.
-class Puppet::Network::Client::Dipper < Puppet::Network::Client
-    @handler = Puppet::Network::Handler.handler(:filebucket)
-    @drivername = :Bucket
-
-    attr_accessor :name
-
-    # Create our bucket client
-    def initialize(hash = {})
-        if hash.include?(:Path)
-            bucket = self.class.handler.new(:Path => hash[:Path])
-            hash.delete(:Path)
-            hash[:Bucket] = bucket
-        end
-
-        super(hash)
-    end
-
-    # Back up a file to our bucket
-    def backup(file)
-        unless FileTest.exists?(file)
-            raise(ArgumentError, "File %s does not exist" % file)
-        end
-        contents = ::File.read(file)
-        unless local?
-            contents = Base64.encode64(contents)
-        end
-        begin
-            return @driver.addfile(contents,file)
-        rescue => detail
-            puts detail.backtrace if Puppet[:trace]
-            raise Puppet::Error, "Could not back up %s: %s" % [file, detail]
-        end
-    end
-
-    # Retrieve a file by sum.
-    def getfile(sum)
-        if newcontents = @driver.getfile(sum)
-            unless local?
-                newcontents = Base64.decode64(newcontents)
-            end
-            return newcontents
-        end
-        return nil
-    end
-
-    # Restore the file
-    def restore(file,sum)
-        restore = true
-        if FileTest.exists?(file)
-            cursum = Digest::MD5.hexdigest(::File.read(file))
-
-            # if the checksum has changed...
-            # this might be extra effort
-            if cursum == sum
-                restore = false
-            end
-        end
-
-        if restore
-            if newcontents = getfile(sum)
-                tmp = ""
-                newsum = Digest::MD5.hexdigest(newcontents)
-                changed = nil
-                if FileTest.exists?(file) and ! FileTest.writable?(file)
-                    changed = ::File.stat(file).mode
-                    ::File.chmod(changed | 0200, file)
-                end
-                ::File.open(file, ::File::WRONLY|::File::TRUNC|::File::CREAT) { |of|
-                    of.print(newcontents)
-                }
-                if changed
-                    ::File.chmod(changed, file)
-                end
-            else
-                Puppet.err "Could not find file with checksum %s" % sum
-                return nil
-            end
-            return newsum
-        else
-            return nil
-        end
-    end
-end
-

data/lib/puppet/network/client/resource.rb

@@ -1,38 +0,0 @@
-# The client for interacting with remote Puppet agents to query and modify
-# remote system state.
-class Puppet::Network::Client::Resource < Puppet::Network::Client
-    def apply(bucket)
-        case bucket
-        when Puppet::TransObject
-            tmp = Puppet::TransBucket.new
-            tmp.push bucket
-            bucket = tmp
-            bucket.name = Facter["hostname"].value
-            bucket.type = "resource"
-        when Puppet::TransBucket
-            # nothing
-        else
-            raise Puppet::DevError, "You must pass a transportable object, not a %s" %
-                bucket.class
-        end
-
-        unless @local
-            bucket = Base64.encode64(YAML::dump(bucket))
-        end
-        report = @driver.apply(bucket, "yaml")
-
-        return report
-    end
-
-    def describe(type, name, retrieve = false, ignore = false)
-        Puppet.info "Describing %s[%s]" % [type.to_s.capitalize, name]
-        text = @driver.describe(type, name, retrieve, ignore, "yaml")
-        @local ? text : YAML::load(Base64.decode64(text))
-    end
-
-    def list(type, ignore = false, base = false)
-        bucket = @driver.list(type, ignore, base, "yaml")
-        @local ? bucket : YAML::load(Base64.decode64(bucket))
-    end
-end
-

data/lib/puppet/network/handler/resource.rb

@@ -1,190 +0,0 @@
-require 'puppet'
-require 'puppet/network/handler'
-
-# Serve Puppet elements.  Useful for querying, copying, and, um, other stuff.
-class Puppet::Network::Handler
-    class Resource < Handler
-        desc "An interface for interacting with client-based resources that can
-        be used for querying or managing remote machines without using Puppet's
-        central server tools.
-
-        The ``describe`` and ``list`` methods return TransBuckets containing
-        TransObject instances (``describe`` returns a single TransBucket),
-        and the ``apply`` method accepts a TransBucket of TransObjects and
-        applies them locally.
-        "
-
-        attr_accessor :local
-
-        @interface = XMLRPC::Service::Interface.new("resource") { |iface|
-            iface.add_method("string apply(string, string)")
-            iface.add_method("string describe(string, string, array, array)")
-            iface.add_method("string list(string, array, string)")
-        }
-
-        side :client
-
-        # Apply a TransBucket as a transaction.
-        def apply(bucket, format = "yaml", client = nil, clientip = nil)
-            unless local?
-                begin
-                    case format
-                    when "yaml"
-                        bucket = YAML::load(Base64.decode64(bucket))
-                    else
-                        raise Puppet::Error, "Unsupported format '%s'" % format
-                    end
-                rescue => detail
-                    raise Puppet::Error, "Could not load YAML TransBucket: %s" % detail
-                end
-            end
-
-            catalog = bucket.to_catalog
-
-            # And then apply the catalog.  This way we're reusing all
-            # the code in there.  It should probably just be separated out, though.
-            transaction = catalog.apply
-
-            # And then clean up
-            catalog.clear(true)
-
-            # It'd be nice to return some kind of report, but... at this point
-            # we have no such facility.
-            return "success"
-        end
-
-        # Describe a given object.  This returns the 'is' values for every property
-        # available on the object type.
-        def describe(type, name, retrieve = nil, ignore = [], format = "yaml", client = nil, clientip = nil)
-            Puppet.info "Describing %s[%s]" % [type.to_s.capitalize, name]
-            @local = true unless client
-            typeklass = nil
-            unless typeklass = Puppet::Type.type(type)
-                raise Puppet::Error, "Puppet type %s is unsupported" % type
-            end
-
-            obj = nil
-
-            retrieve ||= :all
-            ignore ||= []
-
-            begin
-                obj = typeklass.create(:name => name, :check => retrieve)
-            rescue Puppet::Error => detail
-                raise Puppet::Error, "%s[%s] could not be created: %s" %
-                    [type, name, detail]
-            end
-
-            unless obj
-                raise XMLRPC::FaultException.new(
-                    1, "Could not create %s[%s]" % [type, name]
-                )
-            end
-
-            trans = obj.to_trans
-
-            # Now get rid of any attributes they specifically don't want
-            ignore.each do |st|
-                if trans.include? st
-                    trans.delete(st)
-                end
-            end
-
-            # And get rid of any attributes that are nil
-            trans.each do |attr, value|
-                if value.nil?
-                    trans.delete(attr)
-                end
-            end
-
-            unless @local
-                case format
-                when "yaml"
-                    trans = Base64.encode64(YAML::dump(trans))
-                else
-                    raise XMLRPC::FaultException.new(
-                        1, "Unavailable config format %s" % format
-                    )
-                end
-            end
-
-            return trans
-        end
-
-        # Create a new fileserving module.
-        def initialize(hash = {})
-            if hash[:Local]
-                @local = hash[:Local]
-            else
-                @local = false
-            end
-        end
-
-        # List all of the elements of a given type.
-        def list(type, ignore = [], base = nil, format = "yaml", client = nil, clientip = nil)
-            @local = true unless client
-            typeklass = nil
-            unless typeklass = Puppet::Type.type(type)
-                raise Puppet::Error, "Puppet type %s is unsupported" % type
-            end
-
-            # They can pass in false
-            ignore ||= []
-            ignore = [ignore] unless ignore.is_a? Array
-            bucket = Puppet::TransBucket.new
-            bucket.type = typeklass.name
-
-            typeklass.instances.each do |obj|
-                next if ignore.include? obj.name
-
-                #object = Puppet::TransObject.new(obj.name, typeklass.name)
-                bucket << obj.to_trans
-            end
-
-            unless @local
-                case format
-                when "yaml"
-                    begin
-                    bucket = Base64.encode64(YAML::dump(bucket))
-                    rescue => detail
-                        Puppet.err detail
-                        raise XMLRPC::FaultException.new(
-                            1, detail.to_s
-                        )
-                    end
-                else
-                    raise XMLRPC::FaultException.new(
-                        1, "Unavailable config format %s" % format
-                    )
-                end
-            end
-
-            return bucket
-        end
-
-        private
-
-        def authcheck(file, mount, client, clientip)
-            unless mount.allowed?(client, clientip)
-                mount.warning "%s cannot access %s" %
-                    [client, file]
-                raise Puppet::AuthorizationError, "Cannot access %s" % mount
-            end
-        end
-
-        # Deal with ignore parameters.
-        def handleignore(children, path, ignore)
-            ignore.each { |ignore|
-                Dir.glob(File.join(path,ignore), File::FNM_DOTMATCH) { |match|
-                    children.delete(File.basename(match))
-                }
-            }
-            return children
-        end
-
-        def to_s
-            "resource"
-        end
-    end
-end
-