puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/type/notify.rb

@@ -0,0 +1,44 @@
+#
+# Simple module for logging messages on the client-side
+#
+
+module Puppet
+  newtype(:notify) do
+    @doc = "Sends an arbitrary message to the agent run-time log."
+
+    newproperty(:message) do
+      desc "The message to be sent to the log."
+      def sync
+        case @resource["withpath"]
+        when :true
+          send(@resource[:loglevel], self.should)
+        else
+          Puppet.send(@resource[:loglevel], self.should)
+        end
+        return
+      end
+
+      def retrieve
+        :absent
+      end
+
+      def insync?(is)
+        false
+      end
+
+      defaultto { @resource[:name] }
+    end
+
+    newparam(:withpath) do
+      desc "Whether to show the full object path. Defaults to false."
+      defaultto :false
+
+      newvalues(:true, :false)
+    end
+
+    newparam(:name) do
+      desc "An arbitrary tag for your own reference; the name of the message."
+      isnamevar
+    end
+  end
+end

data/lib/vendor/puppet/type/package.rb

@@ -0,0 +1,357 @@
+# Define the different packaging systems.  Each package system is implemented
+# in a module, which then gets used to individually extend each package object.
+# This allows packages to exist on the same machine using different packaging
+# systems.
+
+module Puppet
+  newtype(:package) do
+    @doc = "Manage packages.  There is a basic dichotomy in package
+      support right now:  Some package types (e.g., yum and apt) can
+      retrieve their own package files, while others (e.g., rpm and sun)
+      cannot.  For those package formats that cannot retrieve their own files,
+      you can use the `source` parameter to point to the correct file.
+
+      Puppet will automatically guess the packaging format that you are
+      using based on the platform you are on, but you can override it
+      using the `provider` parameter; each provider defines what it
+      requires in order to function, and you must meet those requirements
+      to use a given provider.
+
+      **Autorequires:** If Puppet is managing the files specified as a
+      package's `adminfile`, `responsefile`, or `source`, the package
+      resource will autorequire those files."
+
+    feature :installable, "The provider can install packages.",
+      :methods => [:install]
+    feature :uninstallable, "The provider can uninstall packages.",
+      :methods => [:uninstall]
+    feature :upgradeable, "The provider can upgrade to the latest version of a
+        package.  This feature is used by specifying `latest` as the
+        desired value for the package.",
+      :methods => [:update, :latest]
+    feature :purgeable, "The provider can purge packages.  This generally means
+        that all traces of the package are removed, including
+        existing configuration files.  This feature is thus destructive
+        and should be used with the utmost care.",
+      :methods => [:purge]
+    feature :versionable, "The provider is capable of interrogating the
+        package database for installed version(s), and can select
+        which out of a set of available versions of a package to
+        install if asked."
+    feature :holdable, "The provider is capable of placing packages on hold
+        such that they are not automatically upgraded as a result of
+        other package dependencies unless explicit action is taken by
+        a user or another package. Held is considered a superset of
+        installed.",
+      :methods => [:hold]
+    feature :install_options, "The provider accepts options to be
+      passed to the installer command."
+
+    ensurable do
+      desc <<-EOT
+        What state the package should be in. On packaging systems that can
+        retrieve new packages on their own, you can choose which package to
+        retrieve by specifying a version number or `latest` as the ensure
+        value. On packaging systems that manage configuration files separately
+        from "normal" system files, you can uninstall config files by
+        specifying `purged` as the ensure value.
+      EOT
+
+      attr_accessor :latest
+
+      newvalue(:present, :event => :package_installed) do
+        provider.install
+      end
+
+      newvalue(:absent, :event => :package_removed) do
+        provider.uninstall
+      end
+
+      newvalue(:purged, :event => :package_purged, :required_features => :purgeable) do
+        provider.purge
+      end
+
+      newvalue(:held, :event => :package_held, :required_features => :holdable) do
+        provider.hold
+      end
+
+      # Alias the 'present' value.
+      aliasvalue(:installed, :present)
+
+      newvalue(:latest, :required_features => :upgradeable) do
+        # Because yum always exits with a 0 exit code, there's a retrieve
+        # in the "install" method.  So, check the current state now,
+        # to compare against later.
+        current = self.retrieve
+        begin
+          provider.update
+        rescue => detail
+          self.fail "Could not update: #{detail}"
+        end
+
+        if current == :absent
+          :package_installed
+        else
+          :package_changed
+        end
+      end
+
+      newvalue(/./, :required_features => :versionable) do
+        begin
+          provider.install
+        rescue => detail
+          self.fail "Could not update: #{detail}"
+        end
+
+        if self.retrieve == :absent
+          :package_installed
+        else
+          :package_changed
+        end
+      end
+
+      defaultto :installed
+
+      # Override the parent method, because we've got all kinds of
+      # funky definitions of 'in sync'.
+      def insync?(is)
+        @lateststamp ||= (Time.now.to_i - 1000)
+        # Iterate across all of the should values, and see how they
+        # turn out.
+
+        @should.each { |should|
+          case should
+          when :present
+            return true unless [:absent, :purged, :held].include?(is)
+          when :latest
+            # Short-circuit packages that are not present
+            return false if is == :absent or is == :purged
+
+            # Don't run 'latest' more than about every 5 minutes
+            if @latest and ((Time.now.to_i - @lateststamp) / 60) < 5
+              #self.debug "Skipping latest check"
+            else
+              begin
+                @latest = provider.latest
+                @lateststamp = Time.now.to_i
+              rescue => detail
+                error = Puppet::Error.new("Could not get latest version: #{detail}")
+                error.set_backtrace(detail.backtrace)
+                raise error
+              end
+            end
+
+            case
+              when is.is_a?(Array) && is.include?(@latest)
+                return true
+              when is == @latest
+                return true
+              when is == :present
+                # This will only happen on retarded packaging systems
+                # that can't query versions.
+                return true
+              else
+                self.debug "#{@resource.name} #{is.inspect} is installed, latest is #{@latest.inspect}"
+            end
+
+
+          when :absent
+            return true if is == :absent or is == :purged
+          when :purged
+            return true if is == :purged
+          # this handles version number matches and
+          # supports providers that can have multiple versions installed
+          when *Array(is)
+            return true
+          end
+        }
+
+        false
+      end
+
+      # This retrieves the current state. LAK: I think this method is unused.
+      def retrieve
+        provider.properties[:ensure]
+      end
+
+      # Provide a bit more information when logging upgrades.
+      def should_to_s(newvalue = @should)
+        if @latest
+          @latest.to_s
+        else
+          super(newvalue)
+        end
+      end
+    end
+
+    newparam(:name) do
+      desc "The package name.  This is the name that the packaging
+      system uses internally, which is sometimes (especially on Solaris)
+      a name that is basically useless to humans.  If you want to
+      abstract package installation, then you can use aliases to provide
+      a common name to packages:
+
+          # In the 'openssl' class
+          $ssl = $operatingsystem ? {
+            solaris => SMCossl,
+            default => openssl
+          }
+
+          # It is not an error to set an alias to the same value as the
+          # object name.
+          package { $ssl:
+            ensure => installed,
+            alias  => openssl
+          }
+
+          . etc. .
+
+          $ssh = $operatingsystem ? {
+            solaris => SMCossh,
+            default => openssh
+          }
+
+          # Use the alias to specify a dependency, rather than
+          # having another selector to figure it out again.
+          package { $ssh:
+            ensure  => installed,
+            alias   => openssh,
+            require => Package[openssl]
+          }
+
+      "
+      isnamevar
+    end
+
+    newparam(:source) do
+      desc "Where to find the actual package.  This must be a local file
+        (or on a network file system) or a URL that your specific
+        packaging type understands; Puppet will not retrieve files for you,
+        although you can manage packages as `file` resources."
+
+      validate do |value|
+        provider.validate_source(value)
+      end
+    end
+
+    newparam(:instance) do
+      desc "A read-only parameter set by the package."
+    end
+
+    newparam(:status) do
+      desc "A read-only parameter set by the package."
+    end
+
+    newparam(:type) do
+      desc "Deprecated form of `provider`."
+
+      munge do |value|
+        warning "'type' is deprecated; use 'provider' instead"
+        @resource[:provider] = value
+
+        @resource[:provider]
+      end
+    end
+
+    newparam(:adminfile) do
+      desc "A file containing package defaults for installing packages.
+        This is currently only used on Solaris.  The value will be
+        validated according to system rules, which in the case of
+        Solaris means that it should either be a fully qualified path
+        or it should be in `/var/sadm/install/admin`."
+    end
+
+    newparam(:responsefile) do
+      desc "A file containing any necessary answers to questions asked by
+        the package.  This is currently used on Solaris and Debian.  The
+        value will be validated according to system rules, but it should
+        generally be a fully qualified path."
+    end
+
+    newparam(:configfiles) do
+      desc "Whether configfiles should be kept or replaced.  Most packages
+        types do not support this parameter. Defaults to `keep`."
+
+      defaultto :keep
+
+      newvalues(:keep, :replace)
+    end
+
+    newparam(:category) do
+      desc "A read-only parameter set by the package."
+    end
+    newparam(:platform) do
+      desc "A read-only parameter set by the package."
+    end
+    newparam(:root) do
+      desc "A read-only parameter set by the package."
+    end
+    newparam(:vendor) do
+      desc "A read-only parameter set by the package."
+    end
+    newparam(:description) do
+      desc "A read-only parameter set by the package."
+    end
+
+    newparam(:allowcdrom) do
+      desc "Tells apt to allow cdrom sources in the sources.list file.
+        Normally apt will bail if you try this."
+
+      newvalues(:true, :false)
+    end
+
+    newparam(:flavor) do
+      desc "Newer versions of OpenBSD support 'flavors', which are
+        further specifications for which type of package you want."
+    end
+
+    newparam(:install_options, :required_features => :install_options) do
+      desc <<-'EOT'
+        A hash of additional options to pass when installing a package. These
+        options are package-specific, and should be documented by the software
+        vendor. The most commonly implemented option is `INSTALLDIR`:
+
+            package { 'mysql':
+              ensure          => installed,
+              provider        => 'msi',
+              source          => 'N:/packages/mysql-5.5.16-winx64.msi',
+              install_options => { 'INSTALLDIR' => 'C:\\mysql-5.5' },
+            }
+
+        Since these options are passed verbatim to `msiexec`, any file paths
+        specified in `install_options` should use a backslash as the separator
+        character rather than a forward slash. This is the **only** place in Puppet
+        where backslash separators should be used. Note that backslashes in
+        double-quoted strings _must_ be double-escaped and backslashes
+        in single-quoted strings _may_ be double-escaped.
+      EOT
+    end
+
+    autorequire(:file) do
+      autos = []
+      [:responsefile, :adminfile].each { |param|
+        if val = self[param]
+          autos << val
+        end
+      }
+
+      if source = self[:source] and absolute_path?(source)
+        autos << source
+      end
+      autos
+    end
+
+    # This only exists for testing.
+    def clear
+      if obj = @parameters[:ensure]
+        obj.latest = nil
+      end
+    end
+
+    # The 'query' method returns a hash of info if the package
+    # exists and returns nil if it does not.
+    def exists?
+      @provider.get(:ensure) != :absent
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+#module Puppet
+#    newtype(:port) do
+#        @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."
+#
+#        ensurable
+#
+#        newproperty(: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 #{value}"
+#                end
+#            end
+#        end
+#
+#        newproperty(:number) do
+#            desc "The port number."
+#        end
+#
+#        newproperty(:description) do
+#            desc "The port description."
+#        end
+#
+#        newproperty(:port_aliases) do
+#            desc 'Any aliases the port might have.  Multiple values must be
+#                specified as an array.  Note that this property is not the same as
+#                the "alias" metaparam; use this property to add aliases to a port
+#                in the services file, and "alias" to aliases for use in your Puppet
+#                scripts.'
+#
+#            # 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 property
+#                    @resource.newmetaparam(
+#                        @resource.class.metaparamclass(:alias), value
+#                    )
+#                end
+#                value
+#            end
+#        end
+#
+#        newproperty(:target) do
+#            desc "The file in which to store service information.  Only used by
+#                those providers that write to disk."
+#
+#            defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
+#                    @resource.class.defaultprovider.default_target
+#                else
+#                    nil
+#                end
+#            }
+#        end
+#
+#        newparam(:name) do
+#            desc "The port name."
+#
+#            isnamevar
+#        end
+#    end
+#end
+

data/lib/vendor/puppet/type/resources.rb

@@ -0,0 +1,131 @@
+require 'puppet'
+
+Puppet::Type.newtype(:resources) do
+  @doc = "This is a metatype that can manage other resource types.  Any
+    metaparams specified here will be passed on to any generated resources,
+    so you can purge umanaged resources but set `noop` to true so the
+    purging is only logged and does not actually happen."
+
+
+  newparam(:name) do
+    desc "The name of the type to be managed."
+
+    validate do |name|
+      raise ArgumentError, "Could not find resource type '#{name}'" unless Puppet::Type.type(name)
+    end
+
+    munge { |v| v.to_s }
+  end
+
+  newparam(:purge, :boolean => true) do
+    desc "Purge unmanaged resources.  This will delete any resource
+      that is not specified in your configuration
+      and is not required by any specified resources."
+
+    newvalues(:true, :false)
+
+    validate do |value|
+      if [:true, true, "true"].include?(value)
+        unless @resource.resource_type.respond_to?(:instances)
+          raise ArgumentError, "Purging resources of type #{@resource[:name]} is not supported, since they cannot be queried from the system"
+        end
+        raise ArgumentError, "Purging is only supported on types that accept 'ensure'" unless @resource.resource_type.validproperty?(:ensure)
+      end
+    end
+  end
+
+  newparam(:unless_system_user) do
+    desc "This keeps system users from being purged.  By default, it
+      does not purge users whose UIDs are less than or equal to 500, but you can specify
+      a different UID as the inclusive limit."
+
+    newvalues(:true, :false, /^\d+$/)
+
+    munge do |value|
+      case value
+      when /^\d+/
+        Integer(value)
+      when :true, true
+        500
+      when :false, false
+        false
+      when Integer; value
+      else
+        raise ArgumentError, "Invalid value #{value.inspect}"
+      end
+    end
+
+    defaultto {
+      if @resource[:name] == "user"
+        500
+      else
+        nil
+      end
+    }
+  end
+
+  def check(resource)
+    @checkmethod ||= "#{self[:name]}_check"
+    @hascheck ||= respond_to?(@checkmethod)
+    if @hascheck
+      return send(@checkmethod, resource)
+    else
+      return true
+    end
+  end
+
+  def able_to_ensure_absent?(resource)
+      resource[:ensure] = :absent
+  rescue ArgumentError, Puppet::Error => detail
+      err "The 'ensure' attribute on #{self[:name]} resources does not accept 'absent' as a value"
+      false
+  end
+
+  # Generate any new resources we need to manage.  This is pretty hackish
+  # right now, because it only supports purging.
+  def generate
+    return [] unless self.purge?
+    resource_type.instances.
+      reject { |r| catalog.resource_refs.include? r.ref }.
+      select { |r| check(r) }.
+      select { |r| r.class.validproperty?(:ensure) }.
+      select { |r| able_to_ensure_absent?(r) }.
+      each { |resource|
+        @parameters.each do |name, param|
+          resource[name] = param.value if param.metaparam?
+        end
+
+        # Mark that we're purging, so transactions can handle relationships
+        # correctly
+        resource.purging
+      }
+  end
+
+  def resource_type
+    unless defined?(@resource_type)
+      unless type = Puppet::Type.type(self[:name])
+        raise Puppet::DevError, "Could not find resource type"
+      end
+      @resource_type = type
+    end
+    @resource_type
+  end
+
+  # Make sure we don't purge users below a certain uid, if the check
+  # is enabled.
+  def user_check(resource)
+    return true unless self[:name] == "user"
+    return true unless self[:unless_system_user]
+
+    resource[:audit] = :uid
+
+    return false if system_users.include?(resource[:name])
+
+    current_values = resource.retrieve_resource
+    current_values[resource.property(:uid)] > self[:unless_system_user]
+  end
+
+  def system_users
+    %w{root nobody bin noaccess daemon sys}
+  end
+end

data/lib/vendor/puppet/type/router.rb

@@ -0,0 +1,17 @@
+#
+# Manage a router abstraction
+#
+
+module Puppet
+  newtype(:router) do
+    @doc = "Manages connected router."
+
+    newparam(:url) do
+      desc <<-EOT
+        An SSH or telnet URL at which to access the router, in the form
+        `ssh://user:pass:enable@host/` or `telnet://user:pass:enable@host/`.
+      EOT
+      isnamevar
+    end
+  end
+end