puppet 0.18.4 → 0.22.4

data/lib/puppet/type/parsedtype/host.rb

@@ -1,144 +0,0 @@
-require 'etc'
-require 'facter'
-require 'puppet/type/parsedtype'
-require 'puppet/type/state'
-
-module Puppet
-    newtype(:host, Puppet::Type::ParsedType) do
-
-        newstate(:ip) do
-            desc "The host's IP address."
-        end
-
-        newstate(:alias) do
-            desc "Any alias the host might have.  Multiple values must be
-                specified as an array.  Note that this state has the same name
-                as one of the metaparams; using this state to set aliases will
-                make those aliases available in your Puppet scripts and also on
-                disk."
-
-            # We have to override the feeding mechanism; it might be nil or 
-            # white-space separated
-            def is=(value)
-                # If it's just whitespace, ignore it
-                case value
-                when /^\s+$/
-                    @is = nil
-                when String
-                    @is = value.split(/\s+/)
-                else
-                    @is = value
-                end
-            end
-
-            # We actually want to return the whole array here, not just the first
-            # value.
-            def should
-                if defined? @should
-                    if @should == [:absent]
-                        return :absent
-                    else
-                        return @should
-                    end
-                else
-                    return []
-                end
-            end
-
-            def should_to_s
-                @should.join(" ")
-            end
-
-            validate do |value|
-                if value =~ /\s/
-                    raise Puppet::Error, "Aliases cannot include whitespace"
-                end
-            end
-
-            munge do |value|
-                if value == :absent or value == "absent"
-                    :absent
-                else
-                    # Add the :alias metaparam in addition to the state
-                    @parent.newmetaparam(@parent.class.metaparamclass(:alias), value)
-                    value
-                end
-            end
-        end
-
-        newparam(:name) do
-            desc "The host name."
-
-            isnamevar
-        end
-
-        @doc = "Installs and manages host entries.  For most systems, these
-            entries will just be in /etc/hosts, but some systems (notably OS X)
-            will have different solutions."
-
-        @instances = []
-
-        @path = "/etc/hosts"
-        @fields = [:ip, :name, :alias]
-
-        @filetype = Puppet::FileType.filetype(:flat)
-
-        # Parse a host file
-        #
-        # This method also stores existing comments, and it stores all host
-        # jobs in order, mostly so that comments are retained in the order
-        # they were written and in proximity to the same jobs.
-        def self.parse(text)
-            count = 0
-            hash = {}
-            text.chomp.split("\n").each { |line|
-                case line
-                when /^#/, /^\s*$/:
-                    # add comments and blank lines to the list as they are
-                    @instances << line 
-                else
-                    if line.sub!(/^(\S+)\s+(\S+)\s*/, '')
-                        hash[:ip] = $1
-                        hash[:name] = $2
-
-                        unless line == ""
-                            line.sub!(/\s*/, '')
-                            line.sub!(/^([^#]+)\s*/) do |value|
-                                aliases = $1
-                                unless aliases =~ /^\s*$/
-                                    hash[:alias] = aliases
-                                end
-
-                                ""
-                            end
-                        end
-                    else
-                        raise Puppet::Error, "Could not match '%s'" % line
-                    end
-
-                    if hash[:alias] == ""
-                        hash.delete(:alias)
-                    end
-
-                    hash2obj(hash)
-
-                    hash.clear
-                    count += 1
-                end
-            }
-        end
-
-        # Convert the current object into a host-style string.
-        def to_record
-            str = "%s\t%s" % [self.state(:ip).value, self[:name]]
-
-            if value = self.value(:alias)
-                str += "\t%s" % value.join("\t")
-            end
-
-            str
-        end
-    end
-end
-
-# $Id: host.rb 1124 2006-04-20 07:00:10Z luke $

data/lib/puppet/type/parsedtype/mount.rb

@@ -1,271 +0,0 @@
-require 'etc'
-require 'facter'
-require 'puppet/type/parsedtype'
-require 'puppet/type/state'
-
-module Puppet
-    newtype(:mount, Puppet::Type::ParsedType) do
-        ensurable do
-            desc "Control what to do with this mount. If the value is 
-                  ``present``, the mount is entered into the mount table, 
-                  but not mounted, if it is ``absent``, the entry is removed 
-                  from the mount table and the filesystem is unmounted if 
-                  currently mounted, if it is ``mounted``, the filesystem 
-                  is entered into the mount table and mounted."
-
-            newvalue(:present) do
-                @parent.create()
-            end
-
-            newvalue(:absent) do
-                @parent.destroy()
-
-                if @parent.mounted?
-                    @parent.unmount
-                end
-
-                :mount_removed
-            end
-
-            newvalue(:mounted) do
-                if @is == :absent
-                    set_present
-                end
-
-                @parent.mount
-
-                :mount_mounted
-            end
-
-            def retrieve
-                if @parent.mounted?
-                    @is = :mounted
-                else
-                    val = super()
-                    @is = val
-                end
-            end
-        end
-
-        newstate(:device) do
-            desc "The device providing the mount.  This can be whatever
-                device is supporting by the mount, including network
-                devices or devices specified by UUID rather than device
-                path, depending on the operating system."
-        end
-
-        # Solaris specifies two devices, not just one.
-        newstate(:blockdevice) do
-            desc "The the device to fsck.  This is state is only valid
-                on Solaris, and in most cases will default to the correct
-                value."
-
-            # Default to the device but with "dsk" replaced with "rdsk".
-            defaultto do
-                if Facter["operatingsystem"].value == "Solaris"
-                    device = @parent.value(:device)
-                    if device =~ %r{/dsk/}
-                        device.sub(%r{/dsk/}, "/rdsk/")
-                    else
-                        nil
-                    end
-                else
-                    nil
-                end
-            end
-        end
-
-        newstate(:fstype) do
-            desc "The mount type.  Valid values depend on the
-                operating system."
-        end
-
-        newstate(:options) do
-            desc "Mount options for the mounts, as they would
-                appear in the fstab."
-        end
-
-        newstate(:pass) do
-            desc "The pass in which the mount is checked."
-        end
-
-        newstate(:atboot) do
-            desc "Whether to mount the mount at boot.  Not all platforms
-                support this."
-        end
-
-        newstate(:dump) do
-            desc "Whether to dump the mount.  Not all platforms
-                support this."
-        end
-
-        newparam(:path) do
-            desc "The mount path for the mount."
-
-            isnamevar
-        end
-
-        @doc = "Manages mounted mounts, including putting mount
-            information into the mount table. The actual behavior depends 
-            on the value of the 'ensure' parameter."
-
-        def self.init
-            @platform = Facter["operatingsystem"].value
-            case @platform
-            when "Solaris":
-                    @path = "/etc/vfstab"
-                @fields = [:device, :blockdevice, :path, :fstype, :pass, :atboot,
-                           :options]
-                @defaults = [ nil ] * @fields.size
-            when "Darwin":
-                    @filetype = Puppet::FileType.filetype(:netinfo)
-                @filetype.format = "fstab"
-                @path = "mounts"
-                @fields = [:device, :path, :fstype, :options, :dump, :pass]
-                @defaults = [ nil ] * @fields.size
-
-                # How to map the dumped table to what we want
-                @fieldnames = {
-                    "name" => :device,
-                    "dir" => :path,
-                    "dump_freq" => :dump,
-                    "passno" => :pass,
-                    "vfstype" => :fstype,
-                    "opts" => :options
-                }
-            else
-                @path = "/etc/fstab"
-                @fields = [:device, :path, :fstype, :options, :dump, :pass]
-                @defaults = [ nil ] * 4 + [ "0", "2" ]
-            end
-
-            # Allow Darwin to override the default filetype
-            unless defined? @filetype
-                @filetype = Puppet::FileType.filetype(:flat)
-            end
-        end
-
-        init
-
-        def self.clear
-            init
-            super
-        end
-
-        # Parse a mount tab.
-        #
-        # This method also stores existing comments, and it stores all
-        # mounts in order, mostly so that comments are retained in the
-        # order they were written and in proximity to the same fses.
-        def self.parse(text)
-            # provide a single exception for darwin & netinfo
-            if @filetype == Puppet::FileType.filetype(:netinfo)
-                parseninfo(text)
-                return 
-            end
-            count = 0
-            hash = {}
-            text.chomp.split("\n").each { |line|
-                case line
-                when /^#/, /^\s*$/:
-                    # add comments and blank lines to the list as they are
-                    comment(line)
-                else
-                    values = line.split(/\s+/)
-                    if @fields.length < values.length
-                        raise Puppet::Error, "Could not parse line %s" % line
-                    end
-
-                    values = @defaults.zip(values).collect { |d, v| v || d }
-                    unless @fields.length == values.length
-                        raise Puppet::Error, "Could not parse line %s" % line
-                    end
-                    
-                    @fields.zip(values).each do |field, value|
-                        hash[field] = value
-                    end
-
-                    hash2obj(hash)
-
-                    hash.clear
-                    count += 1
-                end
-            }
-        end
-
-        # Parse a netinfo table.
-        def self.parseninfo(text)
-            array = @fileobj.to_array(text)
-
-            hash = {}
-            array.each do |record|
-                @fieldnames.each do |name, field|
-                    if value = record[name]
-                        if field == :options
-                            hash[field] = value.join(",")
-                        else
-                            hash[field] = value[0]
-                        end
-                    else
-                        raise ArgumentError, "Field %s was not provided" % [name]
-                    end
-                end
-
-
-                hash2obj(hash)
-                hash.clear
-            end
-        end
-
-        # This only works when the mount point is synced to the fstab.
-        def mount
-            output = %x{mount #{self[:path]} 2>&1}
-
-            unless $? == 0
-                raise Puppet::Error, "Could not mount %s: %s" % [self[:path], output]
-            end
-        end
-
-        # This only works when the mount point is synced to the fstab.
-        def unmount
-            output = %x{umount #{self[:path]}}
-
-            unless $? == 0
-                raise Puppet::Error, "Could not mount %s" % self[:path]
-            end
-        end
-
-        # Is the mount currently mounted?
-        def mounted?
-            platform = Facter["operatingsystem"].value
-            df = "df"
-            case Facter["operatingsystem"].value
-            # Solaris's df prints in a very weird format
-            when "Solaris": df = "df -k"
-            end
-            %x{#{df}}.split("\n").find do |line|
-                fs = line.split(/\s+/)[-1]
-                if platform == "Darwin"
-                    fs == "/private/var/automount" + self[:path] or
-                        fs == self[:path]
-                else
-                    fs == self[:path]
-                end
-            end
-        end
-
-        # Convert the current object into an fstab-style string.
-        def to_record
-            self.class.fields.collect do |field|
-                if value = self.value(field)
-                    value
-                else
-                    raise Puppet::Error,
-                        "Could not retrieve value for %s" % field
-                end
-            end.join("\t")
-        end
-    end
-end
-
-# $Id: mount.rb 1380 2006-07-10 23:13:06Z lutter $

data/lib/puppet/type/parsedtype/port.rb

@@ -1,261 +0,0 @@
-require 'etc'
-require 'facter'
-require 'puppet/type/parsedtype'
-require 'puppet/type/state'
-
-module Puppet
-    newtype(:port, Puppet::Type::ParsedType) do
-        newstate(:protocols) do
-            desc "The protocols the port uses.  Valid values are *udp* and *tcp*.
-                Most services have both protocols, but not all.  If you want
-                both protocols, you must specify that; Puppet replaces the
-                current values, it does not merge with them.  If you specify
-                multiple protocols they must be as an array."
-
-            def is=(value)
-                case value
-                when String
-                    @is = value.split(/\s+/)
-                else
-                    @is = value
-                end
-            end
-
-            def is
-                @is
-            end
-
-            # We actually want to return the whole array here, not just the first
-            # value.
-            def should
-                if defined? @should
-                    if @should[0] == :absent
-                        return :absent
-                    else
-                        return @should
-                    end
-                else
-                    return nil
-                end
-            end
-
-            validate do |value|
-                valids = ["udp", "tcp", "ddp", :absent]
-                unless valids.include? value
-                    raise Puppet::Error,
-                        "Protocols can be either 'udp' or 'tcp', not %s" % value
-                end
-            end
-        end
-
-        newstate(:number) do
-            desc "The port number."
-        end
-
-        newstate(:description) do
-            desc "The port description."
-            isoptional
-        end
-
-        newstate(:alias) do
-            desc "Any aliases the port might have.  Multiple values must be
-                specified as an array.  Note that this state has the same name as
-                one of the metaparams; using this state to set aliases will make
-                those aliases available in your Puppet scripts and also on disk."
-
-            isoptional
-
-            # We have to override the feeding mechanism; it might be nil or 
-            # white-space separated
-            def is=(value)
-                # If it's just whitespace, ignore it
-                case value
-                when /^\s+$/
-                    @is = nil
-                when String
-                    @is = value.split(/\s+/)
-                when Symbol
-                    @is = value
-                else
-                    raise Puppet::DevError, "Invalid value %s" % value.inspect
-                end
-            end
-
-            # We actually want to return the whole array here, not just the first
-            # value.
-            def should
-                if defined? @should
-                    if @should[0] == :absent
-                        return :absent
-                    else
-                        return @should
-                    end
-                else
-                    return nil
-                end
-            end
-
-            validate do |value|
-                if value.is_a? String and value =~ /\s/
-                    raise Puppet::Error,
-                        "Aliases cannot have whitespace in them: %s" %
-                        value.inspect
-                end
-            end
-
-            munge do |value|
-                unless value == "absent" or value == :absent
-                    # Add the :alias metaparam in addition to the state
-                    @parent.newmetaparam(
-                        @parent.class.metaparamclass(:alias), value
-                    )
-                end
-                value
-            end
-        end
-
-        newparam(:name) do
-            desc "The port name."
-
-            isnamevar
-        end
-
-        @doc = "Installs and manages port entries.  For most systems, these
-            entries will just be in /etc/services, but some systems (notably OS X)
-            will have different solutions."
-
-        @path = "/etc/services"
-        @fields = [:ip, :name, :alias]
-
-        @filetype = Puppet::FileType.filetype(:flat)
-
-        # Parse a services file
-        #
-        # This method also stores existing comments, and it stores all port
-        # info in order, mostly so that comments are retained in the order
-        # they were written and in proximity to the same ports.
-        def self.parse(text)
-            count = 0
-            hash = {}
-            text.chomp.split("\n").each { |line|
-                hash.clear
-                case line
-                when /^#/, /^\s*$/:
-                    # add comments and blank lines to the list as they are
-                    @instances << line 
-                else
-                    if line.sub!(/^(\S+)\s+(\d+)\/(\w+)\s*/, '')
-                        hash[:name] = $1
-                        hash[:number] = $2
-                        hash[:protocols] = $3
-
-                        unless line == ""
-                            line.sub!(/^([^#]+)\s*/) do |value|
-                                aliases = $1
-
-                                # Remove any trailing whitespace
-                                aliases.strip!
-                                unless aliases =~ /^\s*$/
-                                    hash[:alias] = aliases
-                                end
-
-                                ""
-                            end
-
-                            line.sub!(/^\s*#\s*(.+)$/) do |value|
-                                desc = $1
-                                unless desc =~ /^\s*$/
-                                    hash[:description] = desc.sub(/\s*$/, '')
-                                end
-
-                                ""
-                            end
-                        end
-                    else
-                        if line =~ /^\s+\d+/ and
-                            Facter["operatingsystem"].value == "Darwin"
-                                #Puppet.notice "Skipping wonky OS X port entry %s" %
-                                #    line.inspect
-                                next
-                        end
-                        raise Puppet::Error, "Could not match '%s'" % line
-                    end
-
-                    # If there's already a service with this name, then check
-                    # to see if the only difference is the proto; if so, just
-                    # add our proto and walk away
-                    if obj = self[hash[:name]]
-                        if obj.portmerge(hash)
-                            next
-                        end
-                    end
-
-                    hash2obj(hash)
-
-                    count += 1
-                end
-            }
-        end
-
-        def portmerge(hash)
-            unless @states.include?(:protocols)
-                return false
-            end
-
-            # This method is only called from parsing, so we only worry
-            # about 'is' values.
-            proto = self.state(:protocols).is
-
-            if proto.nil? or proto == :absent
-                # We are an unitialized object; we've got 'should'
-                # values but no 'is' values
-                return false
-            end
-
-            # If this is happening, our object exists
-            self.is = [:ensure, :present]
-
-            if hash[:protocols]
-                # The protocol can be a symbol, so...
-                if proto.is_a?(Symbol)
-                    proto = []
-                end
-                # Check to see if it already includes our proto
-                unless proto.include?(hash[:protocols])
-                    # We are missing their proto
-                    proto << hash[:protocols]
-                    @states[:protocols].is = proto
-                end
-            end
-
-            if hash.include?(:description) and ! @states.include?(:description)
-                self.is = [:description, hash[:description]]
-            end
-
-            return true
-        end
-
-        # Convert the current object into one or more services entry.
-        def to_record
-            self.state(:protocols).value.collect { |proto|
-                str = "%s\t%s/%s" % [self[:name], self.value(:number),
-                    proto]
-
-                if value = self.value(:alias) and value != :absent
-                    str += "\t%s" % value.join(" ")
-                else
-                    str += "\t"
-                end
-
-                if value = self.value(:description) and value != :absent
-                    str += "\t# %s" % value
-                else
-                    str += "\t"
-                end
-                str
-            }.join("\n")
-        end
-    end
-end
-
-# $Id: port.rb 1156 2006-05-01 01:07:47Z luke $