Moving all of the client and server code into a single network/ directory. In other words, more code structure cleanup.

git-svn-id: https://reductivelabs.com/svn/puppet/trunk@2179 980ebf18-57e1-0310-9a29-db15c13687c0

10 files changed, 0 insertions, 943 deletions

diff --git a/lib/puppet/client/ca.rb b/lib/puppet/client/ca.rb
deleted file mode 100644
index 8904c4a13..000000000
--- a/lib/puppet/client/ca.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-class Puppet::Client::CA < Puppet::Client::ProxyClient
-    @drivername = :CA
-
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::CA
-    self.mkmethods
-
-    def initialize(hash = {})
-        if hash.include?(:CA)
-            if hash[:CA].is_a? Hash
-                hash[:CA] = Puppet::Server::CA.new(hash[:CA])
-            else
-                hash[:CA] = Puppet::Server::CA.new()
-            end
-        end
-
-        super(hash)
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/dipper.rb b/lib/puppet/client/dipper.rb
deleted file mode 100644
index 1422c24f2..000000000
--- a/lib/puppet/client/dipper.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-module Puppet
-    class Client
-        # The client class for filebuckets.
-        class Dipper < Puppet::Client
-            @drivername = :Bucket
-
-            @handler = Puppet::Server::FileBucket
-            
-            attr_accessor :name
-
-            # Create our bucket client
-            def initialize(hash = {})
-                if hash.include?(:Path)
-                    bucket = Puppet::Server::FileBucket.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(BucketError, "File %s does not exist" % file)
-                end
-                contents = File.read(file)
-                unless local?
-                    contents = Base64.encode64(contents)
-                end
-                return @driver.addfile(contents,file)
-            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 = @driver.getfile(sum)
-                        unless local?
-                            newcontents = Base64.decode64(newcontents)
-                        end
-                        tmp = ""
-                        newsum = Digest::MD5.hexdigest(newcontents)
-                        changed = nil
-                        unless FileTest.writable?(file)
-                            changed = File.stat(file).mode
-                            File.chmod(changed | 0200, file)
-                        end
-                        File.open(file,File::WRONLY|File::TRUNC) { |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
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/file.rb b/lib/puppet/client/file.rb
deleted file mode 100644
index 116624003..000000000
--- a/lib/puppet/client/file.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-class Puppet::Client::FileClient < Puppet::Client::ProxyClient
-    @drivername = :FileServer
-
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::FileServer
-
-    self.mkmethods
-
-    def initialize(hash = {})
-        if hash.include?(:FileServer)
-            unless hash[:FileServer].is_a?(Puppet::Server::FileServer)
-                raise Puppet::DevError, "Must pass an actual FS object"
-            end
-        end
-
-        super(hash)
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/log.rb b/lib/puppet/client/log.rb
deleted file mode 100644
index e20c0532c..000000000
--- a/lib/puppet/client/log.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-class Puppet::Client::LogClient < Puppet::Client::ProxyClient
-    @drivername = :Logger
-
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::Logger
-    self.mkmethods
-
-    def initialize(hash = {})
-        if hash.include?(:Logger)
-            hash[:Logger] = Puppet::Server::Logger.new()
-        end
-
-        super(hash)
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/master.rb b/lib/puppet/client/master.rb
deleted file mode 100644
index 046e0c5aa..000000000
--- a/lib/puppet/client/master.rb
+++ /dev/null
@@ -1,654 +0,0 @@
-# The client for interacting with the puppetmaster config server.
-require 'sync'
-require 'timeout'
-
-class Puppet::Client::MasterClient < Puppet::Client
-    unless defined? @@sync
-        @@sync = Sync.new
-    end
-
-    @handler = Puppet::Server::Master
-
-    Puppet.setdefaults("puppetd",
-        :puppetdlockfile => [ "$statedir/puppetdlock",
-            "A lock file to temporarily stop puppetd from doing anything."],
-        :usecacheonfailure => [true,
-            "Whether to use the cached configuration when the remote
-            configuration will not compile.  This option is useful for testing
-            new configurations, where you want to fix the broken configuration
-            rather than reverting to a known-good one."
-        ],
-        :downcasefacts => [false,
-            "Whether facts should be made all lowercase when sent to the server."]
-    )
-
-    Puppet.setdefaults(:puppetd,
-        :configtimeout => [30,
-            "How long the client should wait for the configuration to be retrieved
-            before considering it a failure.  This can help reduce flapping if too
-            many clients contact the server at one time."
-        ],
-        :reportserver => ["$server",
-            "The server to which to send transaction reports."
-        ],
-        :report => [false,
-            "Whether to send reports after every transaction."
-        ]
-    )
-
-    # Plugin information.
-    Puppet.setdefaults("puppet",
-        :pluginpath => ["$vardir/plugins",
-            "Where Puppet should look for plugins.  Multiple directories should
-            be colon-separated, like normal PATH variables."],
-        :plugindest => ["$vardir/plugins",
-            "Where Puppet should store plugins that it pulls down from the central
-            server."],
-        :pluginsource => ["puppet://$server/plugins",
-            "From where to retrieve plugins.  The standard Puppet ``file`` type
-             is used for retrieval, so anything that is a valid file source can
-             be used here."],
-        :pluginsync => [false,
-            "Whether plugins should be synced with the central server."],
-        :pluginsignore => [".svn CVS",
-            "What files to ignore when pulling down plugins."]
-    )
-
-    # Central fact information.
-    Puppet.setdefaults("puppet",
-        :factpath => ["$vardir/facts",
-            "Where Puppet should look for facts.  Multiple directories should
-            be colon-separated, like normal PATH variables."],
-        :factdest => ["$vardir/facts",
-            "Where Puppet should store facts that it pulls down from the central
-            server."],
-        :factsource => ["puppet://$server/facts",
-            "From where to retrieve facts.  The standard Puppet ``file`` type
-             is used for retrieval, so anything that is a valid file source can
-             be used here."],
-        :factsync => [false,
-            "Whether facts should be synced with the central server."],
-        :factsignore => [".svn CVS",
-            "What files to ignore when pulling down facts."]
-    )
-
-    @drivername = :Master
-
-    attr_accessor :objects
-    attr_reader :compile_time
-
-    class << self
-        # Puppetd should only have one instance running, and we need a way
-        # to retrieve it.
-        attr_accessor :instance
-        include Puppet::Util
-    end
-
-    def self.facts
-        # Retrieve the facts from the central server.
-        if Puppet[:factsync]
-            self.getfacts()
-        end
-        
-        down = Puppet[:downcasefacts]
-
-        facts = {}
-        Facter.each { |name,fact|
-            if down
-                facts[name] = fact.to_s.downcase
-            else
-                facts[name] = fact.to_s
-            end
-        }
-
-        # Add our client version to the list of facts, so people can use it
-        # in their manifests
-        facts["clientversion"] = Puppet.version.to_s
-
-        facts
-    end
-
-    # This method actually applies the configuration.
-    def apply(tags = nil, ignoreschedules = false)
-        unless defined? @objects
-            raise Puppet::Error, "Cannot apply; objects not defined"
-        end
-
-        transaction = @objects.evaluate
-
-        if tags
-            transaction.tags = tags
-        end
-
-        if ignoreschedules
-            transaction.ignoreschedules = true
-        end
-
-        transaction.addtimes :config_retrieval => @configtime
-
-        begin
-            transaction.evaluate
-        rescue Puppet::Error => detail
-            Puppet.err "Could not apply complete configuration: %s" %
-                detail
-        rescue => detail
-            Puppet.err "Found a bug: %s" % detail
-            if Puppet[:trace]
-                puts detail.backtrace
-            end
-        ensure
-            Puppet::Util::Storage.store
-        end
-        
-        if Puppet[:report]
-            report(transaction)
-        end
-
-        return transaction
-    ensure
-        if defined? transaction and transaction
-            transaction.cleanup
-        end
-    end
-
-    # Cache the config
-    def cache(text)
-        Puppet.info "Caching configuration at %s" % self.cachefile
-        confdir = File.dirname(Puppet[:localconfig])
-        File.open(self.cachefile + ".tmp", "w", 0660) { |f|
-            f.print text
-        }
-        File.rename(self.cachefile + ".tmp", self.cachefile)
-    end
-
-    def cachefile
-        unless defined? @cachefile
-            @cachefile = Puppet[:localconfig] + ".yaml"
-        end
-        @cachefile
-    end
-
-    def clear
-        #@objects = nil
-        @objects.remove(true)
-        Puppet::Type.allclear
-    end
-
-    # Initialize and load storage
-    def dostorage
-        begin
-            Puppet::Util::Storage.load
-            @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
-        rescue => detail
-            if Puppet[:trace]
-                puts detail.backtrace
-            end
-            Puppet.err "Corrupt state file %s: %s" % [Puppet[:statefile], detail]
-            begin
-                File.unlink(Puppet[:statefile])
-                retry
-            rescue => detail
-                raise Puppet::Error.new("Cannot remove %s: %s" %
-                    [Puppet[:statefile], detail])
-            end
-        end
-    end
-
-    # Check whether our configuration is up to date
-    def fresh?
-        unless self.compile_time
-            return false
-        end
-
-        # We're willing to give a 2 second drift
-        if @driver.freshness - @compile_time.to_i < 1
-            return true
-        else
-            return false
-        end
-    end
-
-    # Let the daemon run again, freely in the filesystem.  Frolick, little
-    # daemon!
-    def enable
-        Puppet::Util::Pidlock.new(Puppet[:puppetdlockfile]).unlock(:anonymous => true)
-    end
-
-    # Stop the daemon from making any configuration runs.
-    def disable
-        Puppet::Util::Pidlock.new(Puppet[:puppetdlockfile]).lock(:anonymous => true)
-    end
-
-    # Retrieve the config from a remote server.  If this fails, then
-    # use the cached copy.
-    def getconfig
-        dostorage()
-        if self.fresh?
-            Puppet.info "Config is up to date"
-            unless defined? @objects
-                begin
-                    @objects = YAML.load(self.retrievecache).to_type
-                rescue => detail
-                    Puppet.warning "Could not load cached configuration: %s" % detail
-                end
-            end
-            return
-        end
-        Puppet.debug("getting config")
-
-        # Retrieve the plugins.
-        if Puppet[:pluginsync]
-            getplugins()
-        end
-
-        facts = self.class.facts
-
-        unless facts.length > 0
-            raise Puppet::ClientError.new(
-                "Could not retrieve any facts"
-            )
-        end
-
-        unless objects = get_actual_config(facts)
-            @objects = nil
-            return
-        end
-
-        unless objects.is_a?(Puppet::TransBucket)
-            raise NetworkClientError,
-                "Invalid returned objects of type %s" % objects.class
-        end
-
-        self.setclasses(objects.classes)
-
-        # Clear all existing objects, so we can recreate our stack.
-        if defined? @objects
-            Puppet::Type.allclear
-
-            # Make sure all of the objects are really gone.
-            @objects.remove(true)
-        end
-        @objects = nil
-
-        # Now convert the objects to real Puppet objects
-        @objects = objects.to_type
-
-        if @objects.nil?
-            raise Puppet::Error, "Configuration could not be processed"
-        end
-
-        # and perform any necessary final actions before we evaluate.
-        @objects.finalize
-
-        return @objects
-    end
-    
-    # A simple proxy method, so it's easy to test.
-    def getplugins
-        self.class.getplugins
-    end
-    
-    # Just so we can specify that we are "the" instance.
-    def initialize(*args)
-        Puppet.config.use(:puppet, :sslcertificates, :puppetd)
-        super
-
-        # This might be nil
-        @configtime = 0
-
-        self.class.instance = self
-        @running = false
-
-        mkdefault_objects
-    end
-
-    # Make the default objects necessary for function.
-    def mkdefault_objects
-        # First create the default scheduling objects
-        Puppet::Type.type(:schedule).mkdefaultschedules
-        
-        # And filebuckets
-        Puppet::Type.type(:filebucket).mkdefaultbucket
-    end
-
-    # Mark that we should restart.  The Puppet module checks whether we're running,
-    # so this only gets called if we're in the middle of a run.
-    def restart
-        # If we're currently running, then just mark for later
-        Puppet.notice "Received signal to restart; waiting until run is complete"
-        @restart = true
-    end
-
-    # Should we restart?
-    def restart?
-        if defined? @restart
-            @restart
-        else
-            false
-        end
-    end
-
-    # Retrieve the cached config
-    def retrievecache
-        if FileTest.exists?(self.cachefile)
-            return File.read(self.cachefile)
-        else
-            return ""
-        end
-    end
-
-    # The code that actually runs the configuration.  
-    def run(tags = nil, ignoreschedules = false)
-        lockfile = Puppet::Util::Pidlock.new(Puppet[:puppetdlockfile])
-        
-        Puppet::Util.sync(:puppetrun).synchronize(Sync::EX) do
-            if !lockfile.lock
-                Puppet.notice "Lock file %s exists; skipping configuration run" %
-                    lockfile.lockfile
-            else
-                @running = true
-                @configtime = thinmark do
-                    self.getconfig
-                end
-
-                if defined? @objects and @objects
-                    unless @local
-                        Puppet.notice "Starting configuration run"
-                    end
-                    benchmark(:notice, "Finished configuration run") do
-                        self.apply(tags, ignoreschedules)
-                    end
-                end
-                @running = false
-            end
-            
-            lockfile.unlock
-
-            # Did we get HUPped during the run?  If so, then restart now that we're
-            # done with the run.
-            if self.restart?
-                Process.kill(:HUP, $$)
-            end
-        end
-    end
-
-    def running?
-        @running
-    end
-
-    # Store the classes in the classfile, but only if we're not local.
-    def setclasses(ary)
-        if @local
-            return
-        end
-        unless ary and ary.length > 0
-            Puppet.info "No classes to store"
-            return
-        end
-        begin
-            File.open(Puppet[:classfile], "w") { |f|
-                f.puts ary.join("\n")
-            }
-        rescue => detail
-            Puppet.err "Could not create class file %s: %s" %
-                [Puppet[:classfile], detail]
-        end
-    end
-
-    private
-
-    # Download files from the remote server, returning a list of all
-    # changed files.
-    def self.download(args)
-        objects = Puppet::Type.type(:component).create(
-            :name => "#{args[:name]}_collector"
-        )
-        hash = {
-            :path => args[:dest],
-            :recurse => true,
-            :source => args[:source],
-            :tag => "#{args[:name]}s",
-            :owner => Process.uid,
-            :group => Process.gid,
-            :backup => false
-        }
-
-        if args[:ignore]
-            hash[:ignore] = args[:ignore].split(/\s+/)
-        end
-        objects.push Puppet::Type.type(:file).create(hash)
-        
-        Puppet.info "Retrieving #{args[:name]}s"
-
-        begin
-            trans = objects.evaluate
-            trans.ignoretags = true
-            Timeout::timeout(self.timeout) do
-                trans.evaluate
-            end
-        rescue Puppet::Error, Timeout::Error => detail
-            if Puppet[:debug]
-                puts detail.backtrace
-            end
-            Puppet.err "Could not retrieve #{args[:name]}s: %s" % detail
-        end
-
-        # Now source all of the changed objects, but only source those
-        # that are top-level.
-        files = []
-        trans.changed?.find_all do |object|
-            yield object if block_given?
-            files << object[:path]
-        end
-        trans.cleanup
-
-        # Now clean up after ourselves
-        objects.remove
-        files
-    end
-
-    # Retrieve facts from the central server.
-    def self.getfacts
-        # Clear all existing definitions.
-        Facter.clear
-
-        # Download the new facts
-        path = Puppet[:factpath].split(":")
-        files = []
-        download(:dest => Puppet[:factdest], :source => Puppet[:factsource],
-            :ignore => Puppet[:factsignore], :name => "fact") do |object|
-
-            next unless path.include?(File.dirname(object[:path]))
-
-            files << object[:path]
-
-        end
-    ensure
-        # Reload everything.
-        if Facter.respond_to? :loadfacts
-            Facter.loadfacts
-        elsif Facter.respond_to? :load
-            Facter.load
-        else
-            raise Puppet::Error,
-                "You must upgrade your version of Facter to use centralized facts"
-        end
-
-        # This loads all existing facts and any new ones.  We have to remove and
-        # reload because there's no way to unload specific facts.
-        loadfacts()
-    end
-
-    # Retrieve the plugins from the central server.  We only have to load the
-    # changed plugins, because Puppet::Type loads plugins on demand.
-    def self.getplugins
-        path = Puppet[:pluginpath].split(":")
-        download(:dest => Puppet[:plugindest], :source => Puppet[:pluginsource],
-            :ignore => Puppet[:pluginsignore], :name => "plugin") do |object|
-
-            next unless path.include?(File.dirname(object[:path]))
-
-            begin
-                Puppet.info "Reloading plugin %s" %
-                    File.basename(File.basename(object[:path])).sub(".rb",'')
-                load object[:path]
-            rescue => detail
-                Puppet.warning "Could not reload plugin %s: %s" %
-                    [object[:path], detail]
-            end
-        end
-    end
-
-    def self.loaddir(dir, type)
-        return unless FileTest.directory?(dir)
-
-        Dir.entries(dir).find_all { |e| e =~ /\.rb$/ }.each do |file|
-            fqfile = File.join(dir, file)
-            begin
-                Puppet.info "Loading #{type} %s" % File.basename(file.sub(".rb",''))
-                Timeout::timeout(self.timeout) do
-                    load fqfile
-                end
-            rescue => detail
-                Puppet.warning "Could not load #{type} %s: %s" % [fqfile, detail]
-            end
-        end
-    end
-
-    def self.loadfacts
-        Puppet[:factpath].split(":").each do |dir|
-            loaddir(dir, "fact")
-        end
-    end
-    
-    def self.timeout
-        @timeout = Puppet[:configtimeout]
-        case @timeout
-        when String:
-            if @timeout =~ /^\d+$/
-                @timeout = Integer(@timeout)
-            else
-                raise ArgumentError, "Configuration timeout must be an integer"
-            end
-        when Integer: # nothing
-        else
-            raise ArgumentError, "Configuration timeout must be an integer"
-        end
-    end
-    
-    # Send off the transaction report.
-    def report(transaction)
-        begin
-            report = transaction.report()
-            if Puppet[:rrdgraph] == true
-                report.graph()
-            end
-            reportclient().report(report)
-        rescue => detail
-            Puppet.err "Reporting failed: %s" % detail
-        end
-    end
-
-    def reportclient
-        unless defined? @reportclient
-            @reportclient = Puppet::Client::Reporter.new(
-                :Server => Puppet[:reportserver]
-            )
-        end
-
-        @reportclient
-    end
-
-    loadfacts()
-    
-    private
-    
-    # Actually retrieve the configuration, either from the server or from a local master.
-    def get_actual_config(facts)
-        if @local
-            return get_local_config(facts)
-        else
-            begin
-                Timeout::timeout(self.class.timeout) do
-                    return get_remote_config(facts)
-                end
-            rescue Timeout::Error
-                Puppet.err "Configuration retrieval timed out"
-                return nil
-            end
-        end
-    end
-    
-    # Retrieve a configuration from a local master.
-    def get_local_config(facts)
-        # If we're local, we don't have to do any of the conversion
-        # stuff.
-        objects = @driver.getconfig(facts, "yaml")
-        @compile_time = Time.now
-
-        if objects == ""
-            raise Puppet::Error, "Could not retrieve configuration"
-        end
-        
-        return objects
-    end
-    
-    # Retrieve a config from a remote master.
-    def get_remote_config(facts)
-        textobjects = ""
-
-        textfacts = CGI.escape(YAML.dump(facts))
-
-        benchmark(:debug, "Retrieved configuration") do
-            # error handling for this is done in the network client
-            begin
-                textobjects = @driver.getconfig(textfacts, "yaml")
-            rescue => detail
-                Puppet.err "Could not retrieve configuration: %s" % detail
-
-                unless Puppet[:usecacheonfailure]
-                    @objects = nil
-                    Puppet.warning "Not using cache on failed configuration"
-                    return
-                end
-            end
-        end
-
-        fromcache = false
-        if textobjects == ""
-            textobjects = self.retrievecache
-            if textobjects == ""
-                raise Puppet::Error.new(
-                    "Cannot connect to server and there is no cached configuration"
-                )
-            end
-            Puppet.warning "Could not get config; using cached copy"
-            fromcache = true
-        else
-            @compile_time = Time.now
-            Puppet::Util::Storage.cache(:configuration)[:compile_time] = @compile_time
-        end
-
-        begin
-            textobjects = CGI.unescape(textobjects)
-        rescue => detail
-            raise Puppet::Error, "Could not CGI.unescape configuration"
-        end
-
-        if @cache and ! fromcache
-            self.cache(textobjects)
-        end
-
-        begin
-            objects = YAML.load(textobjects)
-        rescue => detail
-            raise Puppet::Error,
-                "Could not understand configuration: %s" %
-                detail.to_s
-        end
-        
-        return objects
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/proxy.rb b/lib/puppet/client/proxy.rb
deleted file mode 100644
index 6aff635f4..000000000
--- a/lib/puppet/client/proxy.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# unlike the other client classes (again, this design sucks) this class
-# is basically just a proxy class -- it calls its methods on the driver
-# and that's about it
-class Puppet::Client::ProxyClient < Puppet::Client
-    def self.mkmethods
-        interface = @handler.interface
-        namespace = interface.prefix
-
-
-        interface.methods.each { |ary|
-            method = ary[0]
-            Puppet.debug "%s: defining %s.%s" % [self, namespace, method]
-            define_method(method) { |*args|
-                begin
-                    @driver.send(method, *args)
-                rescue XMLRPC::FaultException => detail
-                    #Puppet.err "Could not call %s.%s: %s" %
-                    #    [namespace, method, detail.faultString]
-                    #raise NetworkClientError,
-                    #    "XMLRPC Error: %s" % detail.faultString
-                    raise NetworkClientError, detail.faultString
-                end
-            }
-        }
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/reporter.rb b/lib/puppet/client/reporter.rb
deleted file mode 100644
index a92842e7c..000000000
--- a/lib/puppet/client/reporter.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-class Puppet::Client::Reporter < Puppet::Client
-    @drivername = :Report
-
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::Report
-
-    def initialize(hash = {})
-        if hash.include?(:Report)
-            hash[:Report] = Puppet::Server::Report.new()
-        end
-
-        super(hash)
-    end
-
-    # Send our report.  We get the transaction report and convert it to YAML
-    # as appropriate.
-    def report(transreport)
-        report = YAML.dump(transreport)
-
-        unless self.local
-            report = CGI.escape(report)
-        end
-
-        # Now send the report
-        file = nil
-        benchmark(:info, "Sent transaction report") do
-            file = @driver.report(report)
-        end
-
-        file
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/resource.rb b/lib/puppet/client/resource.rb
deleted file mode 100644
index 6081b2b66..000000000
--- a/lib/puppet/client/resource.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-class Puppet::Client::Resource < Puppet::Client
-    @drivername = :ResourceServer
-
-    @handler = Puppet::Server::Resource
-
-    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")
-
-        object = nil
-        if @local
-            object = text
-        else
-            object = YAML::load(Base64.decode64(text))
-        end
-
-        return object
-    end
-
-    def initialize(hash = {})
-        if hash.include?(:ResourceServer)
-            unless hash[:ResourceServer].is_a?(Puppet::Server::Resource)
-                raise Puppet::DevError, "Must pass an actual PElement server object"
-            end
-        end
-
-        super(hash)
-    end
-
-    def list(type, ignore = false, base = false)
-        bucket = @driver.list(type, ignore, base, "yaml")
-
-        unless @local
-            bucket = YAML::load(Base64.decode64(bucket))
-        end
-
-        return bucket
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/runner.rb b/lib/puppet/client/runner.rb
deleted file mode 100644
index 9bedf2374..000000000
--- a/lib/puppet/client/runner.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-class Puppet::Client::Runner < Puppet::Client::ProxyClient
-    @drivername = :Runner
-
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::Runner
-    self.mkmethods
-
-    def initialize(hash = {})
-        if hash.include?(:Runner)
-            hash[:Runner] = Puppet::Server::Runner.new()
-        end
-
-        super(hash)
-    end
-end
-
-# $Id$
diff --git a/lib/puppet/client/status.rb b/lib/puppet/client/status.rb
deleted file mode 100644
index ed1445e04..000000000
--- a/lib/puppet/client/status.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-class Puppet::Client::StatusClient < Puppet::Client::ProxyClient
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::ServerStatus
-    self.mkmethods
-end
-
-# $Id$