puppet 0.9.2 → 0.13.0

data/lib/puppet/type/pfile/create.rb

@@ -1,108 +0,0 @@
-module Puppet
-    class State
-        class PFileCreate < Puppet::State
-            require 'etc'
-            @doc = "Whether to create files that don't currently exist.
-                **false**/*true*/*file*/*directory*"
-            @name = :create
-            @event = :file_created
-
-            def shouldprocess(value)
-                # default to just about anything meaning 'true'
-                case value
-                when "false", false, nil:
-                    return false
-                when "true", true, "file", "plain", /^f/:
-                    return "file"
-                when "directory", /^d/:
-                    return "directory"
-                when :notfound:
-                    # this is where a creation is being rolled back
-                    return :notfound
-                else
-                    raise Puppet::Error, "Cannot create files of type %s" % value
-                end
-            end
-
-            def retrieve
-                if stat = @parent.stat(true)
-                    @is = stat.ftype
-                else
-                    @is = :notfound
-                end
-
-                #self.debug "'exists' state is %s" % self.is
-            end
-
-
-            def sync
-                event = nil
-                mode = @parent.should(:mode)
-
-                # First, determine if a user has been specified and if so if
-                # that user has write access to the parent dir
-                asuser = nil
-                if @parent.should(:owner) and ! @parent.should(:owner).is_a?(Symbol)
-                    writeable = Puppet::Util.asuser(@parent.should(:owner)) {
-                        FileTest.writable?(File.dirname(@parent[:path]))
-                    }
-
-                    # If the parent directory is writeable, then we execute
-                    # as the user in question.  Otherwise we'll rely on
-                    # the 'owner' state to do things.
-                    if writeable
-                        asuser = @parent.should(:owner)
-                    end
-                end
-                begin
-                    case self.should
-                    when "file":
-                        # just create an empty file
-                        Puppet::Util.asuser(asuser, @parent.should(:group)) {
-                            if mode
-                                File.open(@parent[:path],"w", mode) {
-                                }
-                            else
-                                File.open(@parent[:path],"w") {
-                                }
-                            end
-                        }
-                        event = :file_created
-                    when "directory":
-                        Puppet::Util.asuser(asuser) {
-                            if mode
-                                Dir.mkdir(@parent.name,mode)
-                            else
-                                Dir.mkdir(@parent.name)
-                            end
-                        }
-                        event = :directory_created
-                    when :notfound:
-                        # this is where the file should be deleted...
-
-                        # This value is only valid when we're rolling back a creation,
-                        # so we verify that the file has not been modified since then.
-                        unless FileTest.size(@parent.name) == 0
-                            raise Puppet::Error.new(
-                                "Created file %s has since been modified; cannot roll back."
-                            )
-                        end
-
-                        File.unlink(@parent.name)
-                    else
-                        error = Puppet::Error.new(
-                            "Somehow got told to create a %s file" % self.should)
-                        raise error
-                    end
-                rescue => detail
-                    raise Puppet::Error.new("Could not create %s: %s" %
-                        [self.should, detail]
-                    )
-                end
-                return event
-            end
-        end
-    end
-end
-
-# $Id: create.rb 731 2005-10-26 04:44:25Z luke $

data/lib/puppet/type/pprocess.rb

@@ -1,97 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# DISABLED
-# I'm only working on services, not processes, right now
-
-module Puppet
-    class State
-        class PProcessRunning < State
-            @doc = "Whether a process should be running.  **true**/*false*"
-            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
-                    Puppet::Message.new(
-                        :level => :error,
-                        :source => self.parent,
-                        :message => "Failed to run ps"
-                    )
-                end
-
-                self.state = running
-                debug "there are #{running} #{self.parent} 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 {
-                    PProcess.uid = uid
-                    PProcess.euid = uid
-                    string = @params[:binary] + (@params[:arguments] || "")
-                    Puppet::Message.new(
-                        :level => :notice,
-                        :source => self.parent,
-                        :message => "starting"
-                    )
-                    Kernel.exec(string)
-                }
-            end
-        end
-    end
-	class Type
-		class PProcess < Type
-			attr_reader :stat, :path
-			@parameters = [:start, :stop, :user, :pattern, :binary, :arguments]
-            @name = :process
-
-            @paramdoc[:start] = "How to start the process.  Must be a fully
-                qualified path."
-            @paramdoc[:stop] = "How to stop the process.  Must be a fully
-                qualified path."
-            @paramdoc[:user] = "Which user to run the proces as."
-            @paramdoc[:pattern] = "The search pattern to use to determine
-                whether the process is currently running."
-            @paramdoc[:binary] = "The binary to actually execute."
-            @paramdoc[:arguments] = "The arguments to pass the binary."
-
-            @doc = "**Disabled.  Use `service` instead.** Manage running
-                processes."
-
-			@namevar = :pattern
-
-			Puppet::Relation.new(self, Puppet::Operation::Start, {
-				:user => :user,
-				:pattern => :pattern,
-				:binary => :binary,
-				:arguments => :arguments
-			})
-
-			Puppet::Relation.new(self, Puppet::Operation::Stop, {
-				:user => :user,
-				:pattern => :pattern
-			})
-
-		end # Puppet::Type::PProcess
-	end # Puppet::Type
-
-end

data/lib/puppet/type/typegen.rb

@@ -1,149 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# $Id: typegen.rb 576 2005-08-23 16:09:14Z luke $
-
-# parse and write configuration files using objects with minimal parsing abilities
-
-require 'etc'
-require 'puppet/type'
-
-module Puppet
-    class Type
-class TypeGenerator < Puppet::Type
-    include Enumerable
-
-    @doc = "..."
-    @namevar = :name
-    @name = :typegen
-    @abstract = true
-
-    @parameters = [:name]
-    @states = []
-
-    @paramdoc[:name] = "..."
-
-    #---------------------------------------------------------------
-    def TypeGenerator.[](name)
-        return @subclasses[name]
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def TypeGenerator.inherited(subclass)
-        #subclass.initvars
-        super(subclass)
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    # we don't need to 'super' here because type.rb already runs initvars
-    # in Type#inherited
-    def TypeGenerator.initvars
-        @subclasses = Hash.new(nil)
-        super
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def TypeGenerator.name
-        return @name
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def TypeGenerator.name=(name)
-        @name = name
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def TypeGenerator.namevar
-        return @namevar || :name
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def TypeGenerator.namevar=(namevar)
-        debug "Setting namevar for %s to %s" % [self,namevar]
-        unless namevar.is_a? Symbol
-            namevar = namevar.intern
-        end
-        @namevar = namevar
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def TypeGenerator.newtype(arghash)
-        unless defined? @parameters
-            raise "Type %s is set up incorrectly" % self
-        end
-
-        arghash.each { |key,value|
-            if key.class != Symbol
-                # convert to a symbol
-                arghash[key.intern] = value
-                arghash.delete key
-                key = key.intern
-            end
-            unless @parameters.include?(key)
-                raise "Invalid argument %s on class %s" %
-                    [key,self]
-            end
-
-        }
-
-        # turn off automatically checking all arguments
-        #@parameters.each { |option|
-        #    unless arghash.include?(option)
-        #        p arghash
-        #        raise "Must pass %s to class %s" %
-        #            [option,self]
-        #    end
-        #}
-
-        if @subclasses.include?(arghash[:name])
-            raise "File type %s already exists" % arghash[:name]
-        end
-
-        klassname = arghash[:name].capitalize
-
-        # create the file type
-        Puppet::Type.module_eval "
-            class %s < %s
-            end" % [klassname,self]
-        klass = eval(klassname)
-        klass.name = arghash[:name]
-
-        @subclasses[arghash[:name]] = klass
-
-        arghash.each { |option,value|
-            method = option.id2name + "="
-            if klass.respond_to?(method)
-                #debug "Setting %s on %s to '%s'" % [option,klass,arghash[option]]
-                klass.send(method,arghash[option])
-            else
-                debug "%s does not respond to %s" % [klass,method]
-            end
-        }
-
-        # i couldn't get the method definition stuff to work
-        # oh well
-        # probably wouldn't want it in the end anyway
-        #@parameters.each { |option|
-        #    writer = option.id2name + "="
-        #    readproc = proc { eval("@" + option.id2name) }
-        #    klass.send(:define_method,option,readproc)
-        #    writeproc = proc { |value| module_eval("@" + option.id2name) = value }
-        #    klass.send(:define_method,writer,writeproc)
-        #    klass.send(writer,hash[option])
-        #}
-
-        #Puppet::Type.inherited(klass)
-        Puppet::Type.buildtypehash
-        return klass
-    end
-    #---------------------------------------------------------------
-end
-#---------------------------------------------------------------
-end
-end

data/lib/puppet/type/typegen/filerecord.rb

@@ -1,243 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# $Id: filerecord.rb 576 2005-08-23 16:09:14Z luke $
-
-# parse and write configuration files using objects with minimal parsing abilities
-
-require 'etc'
-require 'puppet/type'
-require 'puppet/type/typegen'
-
-#---------------------------------------------------------------
-class Puppet::Type::FileRecord < Puppet::Type::TypeGenerator
-    attr_accessor :fields, :namevar, :splitchar, :object
-
-    @parameters = [:name, :splitchar, :fields, :namevar, :filetype, :regex, :joinchar]
-    @abstract = true
-    @metaclass = true
-
-    @namevar = :name
-    @name = :filerecord
-
-    #---------------------------------------------------------------
-    def FileRecord.newtype(hash)
-        #shortname = hash[:name]
-        #hash[:name] = hash[:filetype].name.capitalize + hash[:name].capitalize
-        klass = super(hash)
-        #klass.name = shortname
-        klass.parameters = hash[:fields]
-        #klass.namevar = hash[:namevar]
-        klass.filetype = hash[:filetype]
-        hash.delete(:fields)
-        hash.delete(:namevar)
-        return klass
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.fields=(ary)
-        @fields = ary
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.fields
-        return @fields
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.filetype
-        @filetype
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.filetype=(filetype)
-        if filetype.is_a?(String)
-            @filetype = Puppet::Type::FileType[filetype]
-        elsif filetype.is_a?(Puppet::Type::FileType)
-            @filetype = filetype
-        else
-            raise "Cannot use objects of type %s as filetypes" % filetype 
-        end
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.joinchar=(char)
-        @joinchar = char
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.joinchar
-        unless defined? @joinchar
-            @joinchar = nil
-        end
-        @joinchar
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.match(object,line)
-        matchobj = nil
-        begin
-            matchobj = self.regex.match(line)
-        rescue RegexpError => detail
-            raise
-        end
-
-        if matchobj.nil?
-            return nil
-        else
-            child = self.new(object)
-            child.match = matchobj
-            return child
-        end
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.regex=(regex)
-        @regex = regex
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.regex
-        # the only time @regex is allowed to be nil is if @splitchar is defined
-        if @regex.nil?
-            if @splitchar.nil?
-                raise "%s defined incorrectly -- splitchar or regex must be specified" %
-                    self
-            else
-                ary = []
-                text = @fields.collect { |field|
-                    "([^%s]*)" % @splitchar
-                }.join(@splitchar)
-                begin
-                    @regex = Regexp.new(text)
-                rescue RegexpError => detail
-                    raise "Could not create splitregex from %s" % @splitchar
-                end
-                debug("Created regexp %s" % @regex)
-            end
-        elsif @regex.is_a?(String)
-            begin
-                @regex = Regexp.new(@regex)
-            rescue RegexpError => detail
-                raise "Could not create splitregex from %s" % @regex
-            end
-        end
-        return @regex
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.splitchar=(char)
-        @splitchar = char
-        #@regex = %r{#{char}}
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.splitchar
-        return @splitchar
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    #def [](field)
-    #    @parameters[field]
-    #end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    #def []=(field,value)
-    #    @parameters[field] = value
-    #end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def ==(other)
-        unless self.class == other.class
-            return false
-        end
-
-        unless self.name == other.name
-            return false
-        end
-        @parameters.keys { |field|
-            unless self[field] == other[field]
-                debug("%s -> %s has changed" % [self.name, field])
-                return false
-            end
-        }
-        return true
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def initialize(hash)
-        if self.class == Puppet::Type::FileRecord
-            self.class.newtype(hash)
-            return
-        end
-        @parameters = {}
-        #if block_given?
-        #    yield self
-        #end
-        super(hash)
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def match=(matchobj)
-        @match = matchobj
-        #puts "captures are [%s]" % [matchobj.captures]
-        self.class.fields.zip(matchobj.captures) { |field,value|
-            @parameters[field] = value
-            #puts "%s => %s" % [field,@parameters[field]]
-        }
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def record=(record)
-        begin
-            ary = record.split(self.class.regex)
-        rescue RegexpError=> detail
-            raise RegexpError.new(detail)
-        end
-        self.class.fields.each { |field|
-            @parameters[field] = ary.shift
-            #puts "%s => %s" % [field,@parameters[field]]
-        }
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def name
-        if @parameters.include?(self.class.namevar)
-            return @parameters[self.class.namevar]
-        else
-            raise "No namevar '%s' for objects of type %s" %
-                [self.class.namevar,self.class.to_s]
-        end
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def to_s
-        ary = self.class.fields.collect { |field|
-            if ! @parameters.include?(field)
-                raise "Object %s is missing field %s" % [self.name,field]
-            else
-                @parameters[field]
-            end
-        }.join(self.class.joinchar || self.class.splitchar)
-    end
-    #---------------------------------------------------------------
-end
-#---------------------------------------------------------------