puppet 0.18.4 → 0.22.4

data/lib/puppet/server/filebucket.rb

@@ -1,155 +0,0 @@
-#--------------------
-# accept and serve files
-
-
-require 'webrick'
-require 'xmlrpc/server'
-require 'xmlrpc/client'
-require 'facter'
-require 'digest/md5'
-require 'puppet/base64'
-
-module Puppet
-class Server
-    class BucketError < RuntimeError; end
-    class FileBucket < Handler
-        Puppet.config.setdefaults("filebucket",
-            :bucketdir => {
-                :default => "$vardir/bucket",
-                :mode => 0750,
-                :owner => "$user",
-                :group => "$group",
-                :desc => "Where FileBucket files are stored."
-            }
-        )
-        @interface = XMLRPC::Service::Interface.new("puppetbucket") { |iface|
-            iface.add_method("string addfile(string, string)")
-            iface.add_method("string getfile(string)")
-        }
-
-        Puppet::Util.logmethods(self, true)
-        attr_reader :name, :path
-
-        # this doesn't work for relative paths
-        def FileBucket.paths(base,md5)
-            return [
-                File.join(base, md5),
-                File.join(base, md5, "contents"),
-                File.join(base, md5, "paths")
-            ]
-        end
-
-        def initialize(hash)
-            if hash.include?(:ConflictCheck)
-                @conflictchk = hash[:ConflictCheck]
-                hash.delete(:ConflictCheck)
-            else
-                @conflictchk = true
-            end
-
-            if hash.include?(:Path)
-                @path = hash[:Path]
-                hash.delete(:Path)
-            else
-                if defined? Puppet
-                    @path = Puppet[:bucketdir]
-                else
-                    @path = File.expand_path("~/.filebucket")
-                end
-            end
-
-            Puppet.config.use(:filebucket)
-
-            @name = "filebucket[#{@path}]"
-        end
-
-        # accept a file from a client
-        def addfile(string,path, client = nil, clientip = nil)
-            contents = Base64.decode64(string)
-            md5 = Digest::MD5.hexdigest(contents)
-
-            bpath, bfile, pathpath = FileBucket.paths(@path,md5)
-
-            # if it's a new directory...
-            if Puppet.recmkdir(bpath)
-                msg = "Adding %s(%s)" % [path, md5]
-                msg += " from #{client}" if client
-                self.info msg
-                # ...then just create the file
-                File.open(bfile, File::WRONLY|File::CREAT, 0440) { |of|
-                    of.print contents
-                }
-            else # if the dir already existed...
-                # ...we need to verify that the contents match the existing file
-                if @conflictchk
-                    unless FileTest.exists?(bfile)
-                        raise(BucketError,
-                            "No file at %s for sum %s" % [bfile,md5], caller)
-                    end
-
-                    curfile = File.read(bfile)
-
-                    # If the contents don't match, then we've found a conflict.
-                    # Unlikely, but quite bad.
-                    if curfile != contents
-                        raise(BucketError,
-                            "Got passed new contents for sum %s" % md5, caller)
-                    else
-                        msg = "Got duplicate %s(%s)" % [path, md5]
-                        msg += " from #{client}" if client
-                        self.info msg
-                    end
-                end
-            end
-
-            contents = ""
-
-            # in either case, add the passed path to the list of paths
-            paths = nil
-            addpath = false
-            if FileTest.exists?(pathpath)
-                File.open(pathpath) { |of|
-                    paths = of.readlines.collect { |l| l.chomp }
-                }
-
-                # unless our path is already there...
-                unless paths.include?(path)
-                    addpath = true
-                end
-            else
-                addpath = true
-            end
-
-            # if it's a new file, or if our path isn't in the file yet, add it
-            if addpath
-                File.open(pathpath, File::WRONLY|File::CREAT|File::APPEND) { |of|
-                    of.puts path
-                }
-            end
-
-            return md5
-        end
-
-        def getfile(md5, client = nil, clientip = nil)
-            bpath, bfile, bpaths = FileBucket.paths(@path,md5)
-
-            unless FileTest.exists?(bfile)
-                return false
-            end
-
-            contents = nil
-            File.open(bfile) { |of|
-                contents = of.read
-            }
-
-            return Base64.encode64(contents)
-        end
-
-        def to_s
-            self.name
-        end
-    end
-end
-end
-#
-# $Id: filebucket.rb 1392 2006-07-11 20:58:25Z luke $

data/lib/puppet/server/pelement.rb

@@ -1,188 +0,0 @@
-require 'puppet'
-require 'puppet/server'
-
-module Puppet
-
-# Serve Puppet elements.  Useful for querying, copying, and, um, other stuff.
-class Server::PElement < Server::Handler
-    attr_accessor :local
-
-    @interface = XMLRPC::Service::Interface.new("pelementserver") { |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)")
-    }
-
-    # 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
-
-        component = bucket.to_type
-
-        # Create a client, but specify the remote machine as the server
-        # because the class requires it, even though it's unused
-        client = Puppet::Client::MasterClient.new(:Server => client||"localhost")
-
-        # Set the objects
-        client.objects = component
-
-        # And then apply the configuration.  This way we're reusing all
-        # the code in there.  It should probably just be separated out, though.
-        transaction = client.apply
-
-        # 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 state
-    # available on the object type.
-    def describe(type, name, retrieve = nil, ignore = [], format = "yaml", client = nil, clientip = nil)
-        Puppet.info "Describing %s[%s]" % [type, name]
-        @local = true unless client
-        typeklass = nil
-        unless typeklass = Puppet.type(type)
-            raise Puppet::Error, "Puppet type %s is unsupported" % type
-        end
-
-        obj = nil
-
-        retrieve ||= :all
-        ignore ||= []
-
-        if obj = typeklass[name]
-            obj[:check] = retrieve
-        else
-            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
-        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)
-            raise Puppet::Error, "Puppet type %s is unsupported" % type
-        end
-
-        # They can pass in false
-        ignore ||= []
-        ignore = [ignore] unless ignore.is_a? Array
-        bucket = TransBucket.new
-        bucket.type = typeklass.name
-
-        typeklass.list.each do |obj|
-            next if ignore.include? obj.name
-
-            object = TransObject.new(obj.name, typeklass.name)
-            bucket << object
-        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::Server::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
-        "pelementserver"
-    end
-end
-end
-
-# $Id: pelement.rb 1145 2006-04-28 04:08:38Z luke $

data/lib/puppet/server/report.rb

@@ -1,184 +0,0 @@
-module Puppet
-class Server
-    # A simple server for triggering a new run on a Puppet client.
-    class Report < Handler
-        @interface = XMLRPC::Service::Interface.new("puppetreports") { |iface|
-            iface.add_method("string report(array)")
-        }
-
-        Puppet.setdefaults(:reporting,
-            :reportdirectory => {:default => "$vardir/reports",
-                    :mode => 0750,
-                    :owner => "$user",
-                    :group => "$group",
-                    :desc => "The directory in which to store reports received from the
-                client.  Each client gets a separate subdirectory."},
-            :reports => ["none",
-                "The list of reports to generate.  All reports are looked for
-                in puppet/reports/<name>.rb, and multiple report names should be
-                comma-separated (whitespace is okay)."
-            ]
-        )
-
-        @reports = {}
-
-        class << self
-            attr_reader :hooks
-        end
-
-        def self.reportmethod(report)
-            "report_" + report.to_s
-        end
-
-        # Add a hook for processing reports.
-        def self.newreport(name, &block)
-            name = name.intern if name.is_a? String
-            method = reportmethod(name)
-
-            # We want to define a method so that reports can use 'return'.
-            define_method(method, &block)
-
-            @reports[name] = method
-        end
-
-        # Load a report.
-        def self.report(name)
-            name = name.intern if name.is_a? String
-            unless @reports.include? reportmethod(name)
-                begin
-                    require "puppet/reports/#{name.to_s}"
-                    unless @reports.include? name
-                        Puppet.warning(
-                            "Loaded report file for %s but report was not defined" %
-                            name
-                        )
-                        return nil
-                    end
-                rescue LoadError => detail
-                    if Puppet[:debug]
-                        puts detail.backtrace
-                    end
-                    Puppet.warning "Could not load report %s: %s" %
-                        [name, detail]
-                    return nil
-                end
-            end
-
-            @reports[name]
-        end
-
-        def initialize(*args)
-            super
-            Puppet.config.use(:reporting)
-            Puppet.config.use(:metrics)
-        end
-
-        # Dynamically create the report methods as necessary.
-        def method_missing(name, *args)
-            if name.to_s =~ /^report_(.+)$/
-                if self.class.report($1)
-                    send(name, *args)
-                else
-                    super
-                end
-            else
-                super
-            end
-        end
-
-        # Accept a report from a client.
-        def report(report, client = nil, clientip = nil)
-            # We need the client name for storing files.
-            client ||= Facter["hostname"].value
-
-            # Unescape the report
-            unless @local
-                report = CGI.unescape(report)
-            end
-
-            process(report)
-
-            # We don't want any tracking back in the fs.  Unlikely, but there
-            # you go.
-            client.gsub("..",".")
-
-            dir = File.join(Puppet[:reportdirectory], client)
-
-            unless FileTest.exists?(dir)
-                mkclientdir(client, dir)
-            end
-
-            # Now store the report.
-            now = Time.now.gmtime
-            name = %w{year month day hour min}.collect do |method|
-                # Make sure we're at least two digits everywhere
-                "%02d" % now.send(method).to_s
-            end.join("") + ".yaml"
-
-            file = File.join(dir, name)
-
-            begin
-                File.open(file, "w", 0640) do |f|
-                    f.puts report
-                end
-            rescue => detail
-                if Puppet[:debug]
-                    puts detail.backtrace
-                end
-                Puppet.warning "Could not write report for %s at %s: %s" %
-                    [client, file, detail]
-            end
-
-
-            # Our report is in YAML
-            return file
-        end
-
-        private
-
-        def mkclientdir(client, dir)
-            Puppet.config.setdefaults("reportclient-#{client}",
-                "clientdir-#{client}" => { :default => dir,
-                    :mode => 0750,
-                    :owner => "$user",
-                    :group => "$group"
-                }
-            )
-
-            Puppet.config.use("reportclient-#{client}")
-        end
-
-        # Process the report using all of the existing hooks.
-        def process(report)
-            return if Puppet[:reports] == "none"
-
-            # First convert the report to real objects
-            begin
-                report = YAML.load(report)
-            rescue => detail
-                Puppet.warning "Could not load report: %s" % detail
-                return
-            end
-
-            Puppet[:reports].split(/\s*,\s*/).each do |name|
-                method = self.class.reportmethod(name)
-
-                Puppet.info "Processing report %s" % name
-                begin
-                    send(method, report)
-                rescue NoMethodError => detail
-                    Puppet.warning "No report named '%s'" % name
-                rescue => detail
-                    if Puppet[:debug]
-                        puts detail.backtrace
-                    end
-                    Puppet.err "Report %s failed: %s" %
-                        [name, detail]
-                end
-            end
-        end
-    end
-end
-end
-
-# $Id: report.rb 1390 2006-07-11 20:22:27Z luke $