updates

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

5 files changed, 0 insertions, 785 deletions

diff --git a/lib/blink/objects/file.rb b/lib/blink/objects/file.rb
deleted file mode 100644
index 502a5a404..000000000
--- a/lib/blink/objects/file.rb
+++ /dev/null
@@ -1,213 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# $Id$
-
-require 'digest/md5'
-require 'etc'
-require 'blink/attribute'
-
-module Blink
-    # we first define all of the attribute that our file will use
-    # because the objects must be defined for us to use them in our
-    # definition of the file object
-    class Attribute
-        class FileUID < Blink::Attribute
-            require 'etc'
-            attr_accessor :file
-            @name = :owner
-
-            def retrieve
-                stat = nil
-
-                begin
-                    stat = File.stat(self.object[:path])
-                rescue
-                    # this isn't correct, but what the hell
-                    raise "File '%s' does not exist: #{$!}" % self.object[:path]
-                end
-
-                self.value = stat.uid
-                unless self.should.is_a?(Integer)
-                    begin
-                        user = Etc.getpwnam(self.should)
-                        if user.gid == ""
-                            raise "Could not retrieve uid for %s" % self.object
-                        end
-                        Blink.debug "converting %s to integer %d" %
-                            [self.should,user.uid]
-                        self.should = user.uid
-                    rescue
-                        raise "Could not get any info on user %s" % self.should
-                    end
-                end
-                Blink.debug "chown state is %d" % self.value
-            end
-
-            #def <=>(other)
-            #    if other.is_a?(Integer)
-            #        begin
-            #            other = Etc.getpwnam(other).uid
-            #        rescue
-            #            raise "Could not get uid for #{@params[:uid]}"
-            #        end
-            #    end
-#
-#                self.value <=> other
-#            end
-
-            def sync
-                begin
-                    File.chown(value,-1,self.object[:path])
-                rescue
-                    raise "failed to sync #{@params[:file]}: #{$!}"
-                end
-
-                self.object.newevent(:event => :inode_changed)
-            end
-        end
-
-        # this attribute should actually somehow turn into many attributes,
-        # one for each bit in the mode
-        # I think MetaAttributes are the answer, but I'm not quite sure
-        class FileMode < Blink::Attribute
-            require 'etc'
-
-            @name = :mode
-
-            def retrieve
-                stat = nil
-
-                begin
-                    stat = File.stat(self.object[:path])
-                rescue => error
-                    raise "File %s could not be stat'ed: %s" % [self.object[:path],error]
-                end
-
-                self.value = stat.mode & 007777
-                Blink.debug "chmod state is %o" % self.value
-            end
-
-            def sync
-                begin
-                    File.chmod(self.should,self.object[:path])
-                rescue
-                    raise "failed to chmod #{self.object[:path]}: #{$!}"
-                end
-                self.object.newevent(:event => :inode_changed)
-            end
-        end
-
-        # not used until I can figure out how to solve the problem with
-        # metaattributes
-        class FileSetUID < Blink::Attribute
-            require 'etc'
-
-            @parent = Blink::Attribute::FileMode
-
-            @name = :setuid
-
-            def <=>(other)
-                self.value <=> @parent.value[11]
-            end
-
-            # this just doesn't seem right...
-            def sync
-                tmp = 0
-                if self.value == true
-                    tmp = 1
-                end
-                @parent.value[11] = tmp
-            end
-        end
-
-        class FileGroup < Blink::Attribute
-            require 'etc'
-
-            @name = :group
-
-            def retrieve
-                stat = nil
-
-                begin
-                    stat = File.stat(self.object[:path])
-                rescue
-                    # this isn't correct, but what the hell
-                    raise "File #{self.object[:path]} does not exist: #{$!}"
-                end
-
-                self.value = stat.gid
-
-                # we probably shouldn't actually modify the 'should' value
-                # but i don't see a good way around it right now
-                # mmmm, should
-                unless self.should.is_a?(Integer)
-                    begin
-                        group = Etc.getgrnam(self.should)
-                        # yeah, don't ask me
-                        # this is retarded
-                        #p group
-                        if group.gid == ""
-                            raise "Could not retrieve gid for %s" % self.object
-                        end
-                        Blink.debug "converting %s to integer %d" %
-                            [self.should,group.gid]
-                        self.should = group.gid
-                    rescue
-                        raise "Could not get any info on group %s" % self.should
-                    end
-                end
-                Blink.debug "chgrp state is %d" % self.value
-            end
-
-#            def <=>(other)
-#                # unless we're numeric...
-#                if other.is_a?(Integer)
-#                    begin
-#                        group = Etc.getgrnam(other)
-#                        # yeah, don't ask me
-#                        # this is retarded
-#                        #p group
-#                        other = group.gid
-#                        if other == ""
-#                            raise "Could not retrieve gid for %s" % other
-#                        end
-#                    rescue
-#                        raise "Could not get any info on group %s" % other
-#                    end
-#                end
-#
-#                #puts self.should
-#                self.value <=> other
-#            end
-
-            def sync
-                Blink.debug "setting chgrp state to %d" % self.should
-                begin
-                    # set owner to nil so it's ignored
-                    File.chown(nil,self.should,self.object[:path])
-                rescue
-                    raise "failed to chgrp %s to %s: %s" %
-                        [self.object[:path], self.should, $!]
-                end
-                self.object.newevent(:event => :inode_changed)
-            end
-        end
-    end
-    class Objects
-        class File < Objects
-            attr_reader :stat, :path, :params
-            # class instance variable
-            @params = [
-                Blink::Attribute::FileUID,
-                Blink::Attribute::FileGroup,
-                Blink::Attribute::FileMode,
-                Blink::Attribute::FileSetUID,
-                :path
-            ]
-
-            @name = :file
-            @namevar = :path
-        end # Blink::Objects::File
-    end # Blink::Objects
-
-end
diff --git a/lib/blink/objects/package.rb b/lib/blink/objects/package.rb
deleted file mode 100644
index 407b5871a..000000000
--- a/lib/blink/objects/package.rb
+++ /dev/null
@@ -1,242 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# $Id$
-
-module Blink
-    class Objects
-        # packages are complicated because each package format has completely
-        # different commands.  We need some way to convert specific packages
-        # into the general package object...
-        class Package < Objects
-            attr_reader :version, :format
-            # class instance variable
-            @params = [
-                :install,
-                :format,
-                :version
-            ]
-
-            @name = :package
-            @namevar = :name
-
-            # this is already being done in objects.rb
-            #def Package.inhereted(sub)
-            #    sub.module_eval %q{
-            #        @objects = Hash.new
-            #        @actions = Hash.new
-            #    }
-            #end
-
-            def initialize(hash)
-            end
-
-            def retrieve
-            end
-            
-            def insync?
-            end
-
-            def sync
-            end
-        end # Blink::Objects::Package
-
-        class PackagingType
-            attr_writer :list, :install, :remove, :check
-
-            @@types = Hash.new(false)
-
-            def PackagingType.[](name)
-                if @@types.include?(name)
-                    return @@types[name]
-                else
-                    raise "no such type %s" % name
-                end
-            end
-
-            [:list, :install, :remove, :check].each { |method|
-                self.send(:define_method, method) {
-                    # retrieve the variable
-                    var = eval("@" + method.id2name)
-                    if var.is_a?(Proc)
-                        var.call()
-                    else
-                        raise "only blocks are supported right now"
-                    end
-                }
-            }
-            
-            def initialize(name)
-                if block_given?
-                    yield self
-                end
-
-                @packages = Hash.new(false)
-                @@types[name] = self
-            end
-
-            def retrieve
-                @packages.clear()
-
-                @packages = self.list()
-            end
-        end
-
-        PackagingType.new("dpkg") { |type|
-            type.list = proc {
-                packages = []
-
-                # dpkg only prints as many columns as you have available
-                # which means we don't get all of the info
-                # stupid stupid
-                oldcol = ENV["COLUMNS"]
-                ENV["COLUMNS"] = "500"
-
-                # list out all of the packages
-                open("| dpkg -l") { |process|
-                    # our regex for matching dpkg output
-                    regex = %r{^(\S+)\s+(\S+)\s+(\S+)\s+(.+)$}
-                    fields = [:status, :name, :version, :description]
-                    hash = {}
-
-                    5.times { process.gets } # throw away the header
-
-                    # now turn each returned line into a package object
-                    process.each { |line|
-                        if match = regex.match(line)
-                            hash.clear
-
-                            fields.zip(match.captures) { |field,value|
-                                hash[field] = value
-                            }
-                            packages.push Blink::Objects::Package.new(hash)
-                        else
-                            raise "failed to match dpkg line %s" % line
-                        end
-                    }
-                }
-                ENV["COLUMNS"] = oldcol
-
-                return packages
-            }
-
-            # we need package retrieval mechanisms before we can have package
-            # installation mechanisms...
-            #type.install = proc { |pkg|
-            #    raise "installation not implemented yet"
-            #}
-
-            type.remove = proc { |pkg|
-                cmd = "dpkg -r %s" % pkg.name
-                output = %x{#{cmd}}
-                if $? != 0
-                    raise output
-                end
-            }
-        }
-
-        PackagingType.new("sunpkg") { |type|
-            type.list = proc {
-                packages = []
-                hash = {}
-                names = {
-                    "PKGINST" => :name,
-                    "NAME" => nil,
-                    "CATEGORY" => :category,
-                    "ARCH" => :platform,
-                    "VERSION" => :version,
-                    "BASEDIR" => :root,
-                    "HOTLINE" => nil,
-                    "EMAIL" => nil,
-                    "VENDOR" => :vendor,
-                    "DESC" => :description,
-                    "PSTAMP" => nil,
-                    "INSTDATE" => nil,
-                    "STATUS" => nil,
-                    "FILES" => nil
-                }
-
-                # list out all of the packages
-                open("| pkginfo -l") { |process|
-                    # we're using the long listing, so each line is a separate piece
-                    # of information
-                    process.each { |line|
-                        case line
-                        when /^$/ then
-                            packages.push Blink::Objects::Package.new(hash)
-                            hash.clear
-                        when /\s*(\w+):\s+(.+)/
-                            name = $1
-                            value = $2
-                            if names.include?(name)
-                                hash[names[name]] = value
-                            else
-                                raise "Could not find %s" % name
-                            end
-                        when /\s+\d+.+/
-                            # nothing; we're ignoring the FILES info
-                        end
-                    }
-                }
-                return packages
-            }
-
-            # we need package retrieval mechanisms before we can have package
-            # installation mechanisms...
-            #type.install = proc { |pkg|
-            #    raise "installation not implemented yet"
-            #}
-
-            type.remove = proc { |pkg|
-                cmd = "pkgrm -n %s" % pkg.name
-                output = %x{#{cmd}}
-                if $? != 0
-                    raise output
-                end
-            }
-        }
-
-        # this is how we retrieve packages
-        class PackageSource
-            attr_accessor :uri
-            attr_writer :retrieve
-
-            @@sources = Hash.new(false)
-
-            def PackageSource.get(file)
-                type = file.sub(%r{:.+},'')
-                source = nil
-                if source = @@sources[type]
-                    return source.retrieve(file)
-                else
-                    raise "Unknown package source: %s" % type
-                end
-            end
-
-            def initialize(name)
-                if block_given?
-                    yield self
-                end
-
-                @@sources[name] = self
-            end
-
-            def retrieve(path)
-                @retrieve.call(path)
-            end
-
-        end
-
-        PackageSource.new("file") { |obj|
-            obj.retrieve = proc { |path|
-                # this might not work for windows...
-                file = path.sub(%r{^file://},'')
-
-                if FileTest.exists?(file)
-                    return file
-                else
-                    raise "File %s does not exist" % file
-                end
-            }
-        }
-    end # Blink::Objects
-end
diff --git a/lib/blink/objects/process.rb b/lib/blink/objects/process.rb
deleted file mode 100644
index e2e5722fc..000000000
--- a/lib/blink/objects/process.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-require 'blink/operation'
-require 'blink/operation/processes'
-
-# DISABLED
-# I'm only working on services, not processes, right now
-
-module Blink
-    class Attribute
-        class ProcessRunning < Attribute
-            def retrieve
-                running = 0
-                regex = Regexp.new(@params[:pattern])
-                begin
-                    # this ps is only tested on Solaris
-                    # XXX yeah, this definitely needs to be fixed...
-                    %x{ps -ef -U #{@params[:user]}}.split("\n").each { |process|
-                        if regex.match(process)
-                            running += 1
-                        end
-                    }
-                rescue
-                    # this isn't correct, but what the hell
-                    Blink::Message.new(
-                        :level => :error,
-                        :source => self.object,
-                        :message => "Failed to run ps"
-                    )
-                end
-
-                self.state = running
-                Blink.debug "there are #{running} #{self.object} processes for start"
-            end
-
-            def <=>(other)
-                self.state < 1
-            end
-
-            def fix
-                require 'etc'
-                # ruby is really cool
-                uid = 0
-                if @params[:user].is_a? Integer
-                    uid = @params[:user]
-                else
-                    uid = Etc.getpwnam(@params[:user]).uid
-                end
-                Kernel.fork {
-                    Process.uid = uid
-                    Process.euid = uid
-                    string = @params[:binary] + (@params[:arguments] || "")
-                    Blink::Message.new(
-                        :level => :notice,
-                        :source => self.object,
-                        :message => "starting"
-                    )
-                    Kernel.exec(string)
-                }
-            end
-        end
-    end
-	class Objects
-		class BProcess < Objects
-			attr_reader :stat, :path
-			@params = [:start, :stop, :user, :pattern, :binary, :arguments]
-            @name = :process
-
-			@namevar = :pattern
-
-			Blink::Relation.new(self, Blink::Operation::Start, {
-				:user => :user,
-				:pattern => :pattern,
-				:binary => :binary,
-				:arguments => :arguments
-			})
-
-			Blink::Relation.new(self, Blink::Operation::Stop, {
-				:user => :user,
-				:pattern => :pattern
-			})
-
-		end # Blink::Objects::BProcess
-	end # Blink::Objects
-
-end
diff --git a/lib/blink/objects/service.rb b/lib/blink/objects/service.rb
deleted file mode 100644
index 4e7f4b17e..000000000
--- a/lib/blink/objects/service.rb
+++ /dev/null
@@ -1,138 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# $Id$
-
-# this is our main way of managing processes right now
-#
-# a service is distinct from a process in that services
-# can only be managed through the interface of an init script
-# which is why they have a search path for initscripts and such
-
-module Blink
-    class Attribute
-        class ServiceRunning < Attribute
-            @name = :running
-
-            def retrieve
-                self.value = self.running()
-                Blink.debug "Running value for '%s' is '%s'" %
-                    [self.object.name,self.value]
-            end
-
-            # should i cache this info?
-            def running
-                begin
-                    status = self.object.initcmd("status")
-                    Blink.debug "initcmd status for '%s' is '%s'" %
-                        [self.object.name,status]
-
-                    if status # the command succeeded
-                        return 1
-                    else
-                        return 0
-                    end
-                rescue SystemCallError
-                    raise "Could not execute %s" % initscript
-                end
-
-            end
-
-            def sync
-                if self.running > 0
-                    status = 1
-                else
-                    status = 0
-                end
-                Blink.debug "'%s' status is '%s' and should be '%s'" %
-                    [self,status,should]
-                if self.should > 0
-                    if status < 1
-                        Blink.debug "Starting '%s'" % self
-                        unless self.object.initcmd("start")
-                            raise "Failed to start %s" % self.name
-                        end
-                    else
-                        Blink.debug "'%s' is already running, yo" % self
-                        #Blink.debug "Starting '%s'" % self
-                        #unless self.object.initcmd("start")
-                        #    raise "Failed to start %s" % self.name
-                        #end
-                    end
-                elsif status > 0
-                    Blink.debug "Stopping '%s'" % self
-                    unless self.object.initcmd("stop")
-                        raise "Failed to stop %s" % self.name
-                    end
-                else
-                    Blink.debug "Not running '%s' and shouldn't be running" % self
-                end
-            end
-        end
-    end
-	class Objects
-		class Service < Objects
-			attr_reader :stat
-			@params = [
-                Blink::Attribute::ServiceRunning,
-                :name,
-                :pattern
-            ]
-
-            @name = :service
-			@namevar = :name
-
-            @searchpaths = Array.new
-
-            def Service.addpath(path)
-                unless @searchpaths.include?(path)
-                    # XXX should we check to see if the path exists?
-                    @searchpaths.push(path)
-                end
-            end
-
-            def Service.search(name)
-                @searchpaths.each { |path|
-                    # must specify that we want the top-level File, not Blink::...::File
-                    fqname = ::File.join(path,name)
-                    begin
-                        stat = ::File.stat(fqname)
-                    rescue
-                        # should probably rescue specific errors...
-                        Blink.debug("Could not find %s in %s" % [name,path])
-                        next
-                    end
-
-                    # if we've gotten this far, we found a valid script
-                    return fqname
-                }
-            end
-
-            # it'd be nice if i didn't throw the output away...
-            # this command returns true if the exit code is 0, and returns
-            # false otherwise
-            def initcmd(cmd)
-                script = self.initscript
-
-                #Blink.debug "Executing '%s %s' as initcmd for '%s'" %
-                #    [script,cmd,self]
-
-                rvalue = Kernel.system("%s %s" %
-                        [script,cmd])
-
-                #Blink.debug "'%s' ran with exit status '%s'" %
-                #    [cmd,rvalue]
-
-
-                rvalue
-            end
-
-            def initscript
-                if defined? @initscript
-                    return @initscript
-                else
-                    @initscript = Service.search(self.name)
-                end
-            end
-		end # Blink::Objects::BProcess
-	end # Blink::Objects
-end
diff --git a/lib/blink/objects/symlink.rb b/lib/blink/objects/symlink.rb
deleted file mode 100644
index ca08ea952..000000000
--- a/lib/blink/objects/symlink.rb
+++ /dev/null
@@ -1,106 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# $Id$
-
-require 'etc'
-require 'blink/attribute'
-require 'blink/objects/file'
-
-module Blink
-    # okay, how do we deal with parameters that don't have operations
-    # associated with them?
-    class Attribute
-        class SymlinkTarget < Blink::Attribute
-            require 'etc'
-            attr_accessor :file
-
-            @name = :target
-
-            def create
-                begin
-                    Blink.debug("Creating symlink '%s' to '%s'" %
-                        [self.object[:path],self.should])
-                    unless File.symlink(self.should,self.object[:path])
-                        raise TypeError.new("Could not create symlink '%s'" %
-                            self.object[:path])
-                    end
-                rescue => detail
-                    raise TypeError.new("Cannot create symlink '%s': %s" %
-                        [self.object[:path],detail])
-                end
-            end
-
-            def remove
-                if FileTest.symlink?(self.object[:path])
-                    Blink.debug("Removing symlink '%s'" % self.object[:path])
-                    begin
-                        File.unlink(self.object[:path])
-                    rescue
-                        raise TypeError.new("Failed to remove symlink '%s'" %
-                            self.object[:path])
-                    end
-                elsif FileTest.exists?(self.object[:path])
-                    raise TypeError.new("Cannot remove normal file '%s'" %
-                        self.object[:path])
-                else
-                    Blink.debug("Symlink '%s' does not exist" %
-                        self.object[:path])
-                end
-            end
-
-            def retrieve
-                stat = nil
-
-                if FileTest.symlink?(self.object[:path])
-                    self.value = File.readlink(self.object[:path])
-                    Blink.debug("link value is '%s'" % self.value)
-                    return
-                else
-                    self.value = nil
-                    return
-                end
-            end
-
-            # this is somewhat complicated, because it could exist and be
-            # a file
-            def sync
-                if self.should.nil?
-                    self.remove()
-                else # it should exist and be a symlink
-                    if FileTest.symlink?(self.object[:path])
-                        path = File.readlink(self.object[:path])
-                        if path != self.should
-                            self.remove()
-                            self.create()
-                        end
-                    elsif FileTest.exists?(self.object[:path])
-                        raise TypeError.new("Cannot replace normal file '%s'" %
-                            self.object[:path])
-                    else
-                        self.create()
-                    end
-                end
-
-                self.object.newevent(:event => :inode_changed)
-            end
-        end
-    end
-
-    class Objects
-        class Symlink < Objects
-            attr_reader :stat, :path, :params
-            # class instance variable
-            @params = [
-                Blink::Attribute::FileUID,
-                Blink::Attribute::FileGroup,
-                Blink::Attribute::FileMode,
-                Blink::Attribute::SymlinkTarget,
-                :path
-            ]
-
-            @name = :symlink
-            @namevar = :path
-        end # Blink::Objects::File
-    end # Blink::Objects
-
-end