puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,221 @@
+# 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 Puppet
+
+  newtype(:service) do
+    @doc = "Manage running services.  Service support unfortunately varies
+      widely by platform --- some platforms have very little if any concept of a
+      running service, and some have a very codified and powerful concept.
+      Puppet's service support is usually capable of doing the right thing, but
+      the more information you can provide, the better behaviour you will get.
+
+      Puppet 2.7 and newer expect init scripts to have a working status command.
+      If this isn't the case for any of your services' init scripts, you will
+      need to set `hasstatus` to false and possibly specify a custom status
+      command in the `status` attribute.
+
+      Note that if a `service` receives an event from another resource,
+      the service will get restarted. The actual command to restart the
+      service depends on the platform. You can provide an explicit command for
+      restarting with the `restart` attribute, or you can set `hasrestart` to
+      true to use the init script's restart command; if you do neither, the
+      service's stop and start commands will be used."
+
+    feature :refreshable, "The provider can restart the service.",
+      :methods => [:restart]
+
+    feature :enableable, "The provider can enable and disable the service",
+      :methods => [:disable, :enable, :enabled?]
+
+    feature :controllable, "The provider uses a control variable."
+
+    newproperty(:enable, :required_features => :enableable) do
+      desc "Whether a service should be enabled to start at boot.
+        This property behaves quite differently depending on the platform;
+        wherever possible, it relies on local tools to enable or disable
+        a given service."
+
+      newvalue(:true, :event => :service_enabled) do
+        provider.enable
+      end
+
+      newvalue(:false, :event => :service_disabled) do
+        provider.disable
+      end
+
+      newvalue(:manual, :event => :service_manual_start) do
+        provider.manual_start
+      end
+
+      def retrieve
+        provider.enabled?
+      end
+
+      validate do |value|
+        if value == :manual and !Puppet.features.microsoft_windows?
+          raise Puppet::Error.new("Setting enable to manual is only supported on Microsoft Windows.")
+        end
+      end
+    end
+
+    # Handle whether the service should actually be running right now.
+    newproperty(:ensure) do
+      desc "Whether a service should be running."
+
+      newvalue(:stopped, :event => :service_stopped) do
+        provider.stop
+      end
+
+      newvalue(:running, :event => :service_started) do
+        provider.start
+      end
+
+      aliasvalue(:false, :stopped)
+      aliasvalue(:true, :running)
+
+      def retrieve
+        provider.status
+      end
+
+      def sync
+        event = super()
+
+        if property = @resource.property(:enable)
+          val = property.retrieve
+          property.sync unless property.safe_insync?(val)
+        end
+
+        event
+      end
+    end
+
+    newparam(:binary) do
+      desc "The path to the daemon.  This is only used for
+        systems that do not support init scripts.  This binary will be
+        used to start the service if no `start` parameter is
+        provided."
+    end
+
+    newparam(:hasstatus) do
+      desc "Declare whether the service's init script has a functional status
+        command; defaults to `true`. This attribute's default value changed in
+        Puppet 2.7.0.
+
+        The init script's status command must return 0 if the service is
+        running and a nonzero value otherwise. Ideally, these exit codes
+        should conform to [the LSB's specification][lsb-exit-codes] for init
+        script status actions, but Puppet only considers the difference
+        between 0 and nonzero to be relevant.
+
+        If a service's init script does not support any kind of status command,
+        you should set `hasstatus` to false and either provide a specific
+        command using the `status` attribute or expect that Puppet will look for
+        the service name in the process table. Be aware that 'virtual' init
+        scripts (like 'network' under Red Hat systems) will respond poorly to
+        refresh events from other resources if you override the default behavior
+        without providing a status command."
+
+      newvalues(:true, :false)
+
+      defaultto :true
+    end
+    newparam(:name) do
+      desc <<-EOT
+        The name of the service to run.
+
+        This name is used to find the service; on platforms where services
+        have short system names and long display names, this should be the
+        short name. (To take an example from Windows, you would use "wuauserv"
+        rather than "Automatic Updates.")
+      EOT
+      isnamevar
+    end
+
+    newparam(:path) do
+      desc "The search path for finding init scripts.  Multiple values should
+        be separated by colons or provided as an array."
+
+      munge do |value|
+        value = [value] unless value.is_a?(Array)
+        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+        # It affects stand-alone blocks, too.
+        paths = value.flatten.collect { |p| x = p.split(File::PATH_SEPARATOR) }.flatten
+      end
+
+      defaultto { provider.class.defpath if provider.class.respond_to?(:defpath) }
+    end
+    newparam(:pattern) do
+      desc "The pattern to search for in the process table.
+        This is used for stopping services on platforms that do not
+        support init scripts, and is also used for determining service
+        status on those service whose init scripts do not include a status
+        command.
+
+        Defaults to the name of the service. The pattern can be a simple string
+        or any legal Ruby pattern."
+
+      defaultto { @resource[:binary] || @resource[:name] }
+    end
+    newparam(:restart) do
+      desc "Specify a *restart* command manually.  If left
+        unspecified, the service will be stopped and then started."
+    end
+    newparam(:start) do
+      desc "Specify a *start* command manually.  Most service subsystems
+        support a `start` command, so this will not need to be
+        specified."
+    end
+    newparam(:status) do
+      desc "Specify a *status* command manually.  This command must
+        return 0 if the service is running and a nonzero value otherwise.
+        Ideally, these exit codes should conform to [the LSB's
+        specification][lsb-exit-codes] for init script status actions, but
+        Puppet only considers the difference between 0 and nonzero to be
+        relevant.
+
+        If left unspecified, the status of the service will be determined
+        automatically, usually by looking for the service in the process
+        table.
+
+        [lsb-exit-codes]: http://refspecs.freestandards.org/LSB_3.1.1/LSB-Core-generic/LSB-Core-generic/iniscrptact.html"
+    end
+
+    newparam(:stop) do
+      desc "Specify a *stop* command manually."
+    end
+
+    newparam(:control) do
+      desc "The control variable used to manage services (originally for HP-UX).
+        Defaults to the upcased service name plus `START` replacing dots with
+        underscores, for those providers that support the `controllable` feature."
+      defaultto { resource.name.gsub(".","_").upcase + "_START" if resource.provider.controllable? }
+    end
+
+    newparam :hasrestart do
+      desc "Specify that an init script has a `restart` command.  If this is
+        false and you do not specify a command in the `restart` attribute,
+        the init script's `stop` and `start` commands will be used. Defaults
+        to true; note that this is a change from earlier versions of Puppet."
+      newvalues(:true, :false)
+    end
+
+    newparam(:manifest) do
+      desc "Specify a command to config a service, or a path to a manifest to do so."
+    end
+
+    # Basically just a synonym for restarting.  Used to respond
+    # to events.
+    def refresh
+      # Only restart if we're actually running
+      if (@parameters[:ensure] || newattr(:ensure)).retrieve == :running
+        provider.restart
+      else
+        debug "Skipping restart; service is not running"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Puppet
+  newtype(:ssh_authorized_key) do
+    @doc = "Manages SSH authorized keys. Currently only type 2 keys are
+    supported.
+
+    **Autorequires:** If Puppet is managing the user account in which this
+    SSH key should be installed, the `ssh_authorized_key` resource will autorequire
+    that user."
+
+    ensurable
+
+    newparam(:name) do
+      desc "The SSH key comment. This attribute is currently used as a
+      system-wide primary key and therefore has to be unique."
+
+      isnamevar
+
+    end
+
+    newproperty(:type) do
+      desc "The encryption type used: ssh-dss or ssh-rsa."
+
+      newvalues :'ssh-dss', :'ssh-rsa', :'ecdsa-sha2-nistp256', :'ecdsa-sha2-nistp384', :'ecdsa-sha2-nistp521'
+
+      aliasvalue(:dsa, :'ssh-dss')
+      aliasvalue(:rsa, :'ssh-rsa')
+    end
+
+    newproperty(:key) do
+      desc "The key itself; generally a long string of hex digits."
+
+      validate do |value|
+        raise Puppet::Error, "Key must not contain whitespace: #{value}" if value =~ /\s/
+      end
+    end
+
+    newproperty(:user) do
+      desc "The user account in which the SSH key should be installed.
+      The resource will automatically depend on this user."
+    end
+
+    newproperty(:target) do
+      desc "The absolute filename in which to store the SSH key. This
+      property is optional and should only be used in cases where keys
+      are stored in a non-standard location (i.e.` not in
+      `~user/.ssh/authorized_keys`)."
+
+      defaultto :absent
+
+      def should
+        return super if defined?(@should) and @should[0] != :absent
+
+        return nil unless user = resource[:user]
+
+        begin
+          return File.expand_path("~#{user}/.ssh/authorized_keys")
+        rescue
+          Puppet.debug "The required user is not yet present on the system"
+          return nil
+        end
+      end
+
+      def insync?(is)
+        is == should
+      end
+    end
+
+    newproperty(:options, :array_matching => :all) do
+      desc "Key options, see sshd(8) for possible values. Multiple values
+        should be specified as an array."
+
+      defaultto do :absent end
+
+      def is_to_s(value)
+        if value == :absent or value.include?(:absent)
+          super
+        else
+          value.join(",")
+        end
+      end
+
+      def should_to_s(value)
+        if value == :absent or value.include?(:absent)
+          super
+        else
+          value.join(",")
+        end
+      end
+
+      validate do |value|
+        unless value == :absent or value =~ /^[-a-z0-9A-Z_]+(?:=\".*?\")?$/
+          raise Puppet::Error, "Option #{value} is not valid. A single option must either be of the form 'option' or 'option=\"value\". Multiple options must be provided as an array"
+        end
+      end
+    end
+
+    autorequire(:user) do
+      should(:user) if should(:user)
+    end
+
+    validate do
+      # Go ahead if target attribute is defined
+      return if @parameters[:target].shouldorig[0] != :absent
+
+      # Go ahead if user attribute is defined
+      return if @parameters.include?(:user)
+
+      # If neither target nor user is defined, this is an error
+      raise Puppet::Error, "Attribute 'user' or 'target' is mandatory"
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Puppet
+  newtype(:sshkey) do
+    @doc = "Installs and manages ssh host keys.  At this point, this type
+      only knows how to install keys into `/etc/ssh/ssh_known_hosts`.  See
+      the `ssh_authorized_key` type to manage authorized keys."
+
+    ensurable
+
+    newproperty(:type) do
+      desc "The encryption type used.  Probably ssh-dss or ssh-rsa."
+
+      newvalues :'ssh-dss', :'ssh-rsa', :'ecdsa-sha2-nistp256', :'ecdsa-sha2-nistp384', :'ecdsa-sha2-nistp521'
+
+      aliasvalue(:dsa, :'ssh-dss')
+      aliasvalue(:rsa, :'ssh-rsa')
+    end
+
+    newproperty(:key) do
+      desc "The key itself; generally a long string of hex digits."
+    end
+
+    # FIXME This should automagically check for aliases to the hosts, just
+    # to see if we can automatically glean any aliases.
+    newproperty(:host_aliases) do
+      desc 'Any aliases the host might have.  Multiple values must be
+        specified as an array.'
+
+      attr_accessor :meta
+
+      def insync?(is)
+        is == @should
+      end
+      # We actually want to return the whole array here, not just the first
+      # value.
+      def should
+        defined?(@should) ? @should : nil
+      end
+
+      validate do |value|
+        if value =~ /\s/
+          raise Puppet::Error, "Aliases cannot include whitespace"
+        end
+        if value =~ /,/
+          raise Puppet::Error, "Aliases must be provided as an array, not a comma-separated list"
+        end
+      end
+    end
+
+    newparam(:name) do
+      desc "The host name that the key is associated with."
+
+      isnamevar
+
+      validate do |value|
+        raise Puppet::Error, "Resourcename cannot include whitespaces" if value =~ /\s/
+        raise Puppet::Error, "No comma in resourcename allowed. If you want to specify aliases use the host_aliases property" if value.include?(',')
+      end
+    end
+
+    newproperty(:target) do
+      desc "The file in which to store the ssh key.  Only used by
+        the `parsed` provider."
+
+      defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
+        @resource.class.defaultprovider.default_target
+        else
+          nil
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+Puppet::Type.newtype(:stage) do
+  desc "A resource type for specifying run stages.  The actual stage should
+  be specified on resources:
+
+      class { foo: stage => pre }
+
+  And you must manually control stage order:
+
+      stage { pre: before => Stage[main] }
+
+  You automatically get a 'main' stage created, and by default all resources
+  get inserted into that stage.
+
+  You can only set stages on class resources, not normal builtin resources."
+
+  newparam :name do
+    desc "The name of the stage. This will be used as the 'stage' for each resource."
+  end
+end