bolt 0.20.0 → 0.20.2

data/vendored/puppet/lib/puppet/type/scheduled_task.rb

@@ -0,0 +1,183 @@
+require 'puppet/util'
+
+Puppet::Type.newtype(:scheduled_task) do
+  include Puppet::Util
+
+  @doc = "Installs and manages Windows Scheduled Tasks.  All attributes
+    except `name`, `command`, and `trigger` are optional; see the description
+    of the `trigger` attribute for details on setting schedules."
+
+  ensurable
+
+  newproperty(:enabled) do
+    desc "Whether the triggers for this task should be enabled. This attribute
+      affects every trigger for the task; triggers cannot be enabled or
+      disabled individually."
+
+    newvalue(:true,  :event => :task_enabled)
+    newvalue(:false, :event => :task_disabled)
+
+    defaultto(:true)
+  end
+
+  newparam(:name) do
+    desc "The name assigned to the scheduled task.  This will uniquely
+      identify the task on the system."
+
+    isnamevar
+  end
+
+  newproperty(:command) do
+    desc "The full path to the application to run, without any arguments."
+
+    validate do |value|
+      raise Puppet::Error.new(_('Must be specified using an absolute path.')) unless absolute_path?(value)
+    end
+    munge do |value|
+      # windows converts slashes to backslashes, so the *is* value
+      # has backslashes. Do the same for the *should* value, so that
+      # we are slash-insensitive. See #13009
+      File.expand_path(value).gsub(/\//, '\\')
+    end
+  end
+
+  newproperty(:working_dir) do
+    desc "The full path of the directory in which to start the command."
+
+    validate do |value|
+      raise Puppet::Error.new(_('Must be specified using an absolute path.')) unless absolute_path?(value)
+    end
+  end
+
+  newproperty(:arguments) do
+    desc "Any arguments or flags that should be passed to the command. Multiple arguments
+      should be specified as a space-separated string."
+  end
+
+  newproperty(:user) do
+    desc "The user to run the scheduled task as.  Please note that not
+      all security configurations will allow running a scheduled task
+      as 'SYSTEM', and saving the scheduled task under these
+      conditions will fail with a reported error of 'The operation
+      completed successfully'.  It is recommended that you either
+      choose another user to run the scheduled task, or alter the
+      security policy to allow v1 scheduled tasks to run as the
+      'SYSTEM' account.  Defaults to 'SYSTEM'.
+
+      Please also note that Puppet must be running as a privileged user
+      in order to manage `scheduled_task` resources. Running as an
+      unprivileged user will result in 'access denied' errors."
+
+    defaultto :system
+
+    def insync?(current)
+      provider.user_insync?(current, @should)
+    end
+  end
+
+  newparam(:password) do
+    desc "The password for the user specified in the 'user' attribute.
+      This is only used if specifying a user other than 'SYSTEM'.
+      Since there is no way to retrieve the password used to set the
+      account information for a task, this parameter will not be used
+      to determine if a scheduled task is in sync or not."
+  end
+
+  newproperty(:trigger, :array_matching => :all) do
+    desc <<-'EOT'
+      One or more triggers defining when the task should run. A single trigger is
+      represented as a hash, and multiple triggers can be specified with an array of
+      hashes.
+
+      A trigger can contain the following keys:
+
+      * For all triggers:
+          * `schedule` **(Required)** --- What kind of trigger this is.
+            Valid values are `daily`, `weekly`, `monthly`, or `once`. Each kind
+            of trigger is configured with a different set of keys; see the
+            sections below. (`once` triggers only need a start time/date.)
+          * `start_time` **(Required)** --- The time of day when the trigger should
+            first become active. Several time formats will work, but we
+            suggest 24-hour time formatted as HH:MM.
+          * `start_date` ---  The date when the trigger should first become active.
+            Defaults to the current date. You should format dates as YYYY-MM-DD,
+            although other date formats may work. (Under the hood, this uses `Date.parse`.)
+          * `minutes_interval` --- The repeat interval in minutes.
+          * `minutes_duration` --- The duration in minutes, needs to be greater than the
+            minutes_interval.
+      * For `daily` triggers:
+          * `every` --- How often the task should run, as a number of days. Defaults
+            to 1. ("2" means every other day, "3" means every three days, and so on)
+      * For `weekly` triggers:
+          * `every` --- How often the task should run, as a number of weeks. Defaults
+            to 1. ("2" means every other week, "3" means every three weeks, and so on)
+          * `day_of_week` --- Which days of the week the task should run, as an array.
+            Defaults to all days. Each day must be one of `mon`, `tues`,
+            `wed`, `thurs`, `fri`, `sat`, `sun`, or `all`.
+      * For `monthly` (by date) triggers:
+          * `months` --- Which months the task should run, as an array. Defaults to
+            all months. Each month must be an integer between 1 and 12.
+          * `on` **(Required)** --- Which days of the month the task should run,
+            as an array. Each day must be an integer between 1 and 31.
+      * For `monthly` (by weekday) triggers:
+          * `months` --- Which months the task should run, as an array. Defaults to
+            all months. Each month must be an integer between 1 and 12.
+          * `day_of_week` **(Required)** --- Which day of the week the task should
+            run, as an array with only one element. Each day must be one of `mon`,
+            `tues`, `wed`, `thurs`, `fri`, `sat`, `sun`, or `all`.
+          * `which_occurrence` **(Required)** --- The occurrence of the chosen weekday
+            when the task should run. Must be one of `first`, `second`, `third`,
+            `fourth`, or `fifth`.
+
+
+      Examples:
+
+          # Run at 8am on the 1st and 15th days of the month in January, March,
+          # May, July, September, and November, starting after August 31st, 2011.
+          trigger => {
+            schedule   => monthly,
+            start_date => '2011-08-31',   # Defaults to current date
+            start_time => '08:00',        # Must be specified
+            months     => [1,3,5,7,9,11], # Defaults to all
+            on         => [1, 15],        # Must be specified
+          }
+
+          # Run at 8am on the first Monday of the month for January, March, and May,
+          # starting after August 31st, 2011.
+          trigger => {
+            schedule         => monthly,
+            start_date       => '2011-08-31', # Defaults to current date
+            start_time       => '08:00',      # Must be specified
+            months           => [1,3,5],      # Defaults to all
+            which_occurrence => first,        # Must be specified
+            day_of_week      => [mon],        # Must be specified
+          }
+
+          # Run daily repeating every 30 minutes between 9am and 5pm (480 minutes) starting after August 31st, 2011.
+          trigger => {
+            schedule         => daily,
+            start_date       => '2011-08-31', # Defaults to current date
+            start_time       => '8:00',       # Must be specified
+            minutes_interval => 30,
+            minutes_duration => 480,
+          }
+
+    EOT
+
+    validate do |value|
+      provider.validate_trigger(value)
+    end
+
+    def insync?(current)
+      provider.trigger_insync?(current, @should)
+    end
+
+    def should_to_s(new_value=@should)
+      super(new_value)
+    end
+
+    def is_to_s(current_value=@is)
+      super(current_value)
+    end
+  end
+end

data/vendored/puppet/lib/puppet/type/selboolean.rb

@@ -0,0 +1,26 @@
+module Puppet
+  Type.newtype(:selboolean) do
+    @doc = "Manages SELinux booleans on systems with SELinux support.  The supported booleans
+      are any of the ones found in `/selinux/booleans/`."
+
+    newparam(:name) do
+      desc "The name of the SELinux boolean to be managed."
+      isnamevar
+    end
+
+    newproperty(:value) do
+      desc "Whether the SELinux boolean should be enabled or disabled."
+      newvalue(:on)
+      newvalue(:off)
+    end
+
+    newparam(:persistent) do
+      desc "If set true, SELinux booleans will be written to disk and persist across reboots.
+        The default is `false`."
+
+      defaultto :false
+      newvalues(:true, :false)
+    end
+
+  end
+end

data/vendored/puppet/lib/puppet/type/selmodule.rb

@@ -0,0 +1,59 @@
+#
+# Simple module for managing SELinux policy modules
+#
+
+Puppet::Type.newtype(:selmodule) do
+  @doc = "Manages loading and unloading of SELinux policy modules
+    on the system.  Requires SELinux support.  See man semodule(8)
+    for more information on SELinux policy modules.
+
+    **Autorequires:** If Puppet is managing the file containing this SELinux
+    policy module (which is either explicitly specified in the `selmodulepath`
+    attribute or will be found at {`selmoduledir`}/{`name`}.pp), the selmodule
+    resource will autorequire that file."
+
+  ensurable
+
+  newparam(:name) do
+    desc "The name of the SELinux policy to be managed.  You should not
+      include the customary trailing .pp extension."
+    isnamevar
+  end
+
+  newparam(:selmoduledir) do
+
+    desc "The directory to look for the compiled pp module file in.
+      Currently defaults to `/usr/share/selinux/targeted`.  If the
+      `selmodulepath` attribute is not specified, Puppet will expect to find
+      the module in `<selmoduledir>/<name>.pp`, where `name` is the value of the
+      `name` parameter."
+
+    defaultto "/usr/share/selinux/targeted"
+  end
+
+  newparam(:selmodulepath) do
+
+    desc "The full path to the compiled .pp policy module.  You only need to use
+      this if the module file is not in the `selmoduledir` directory."
+
+  end
+
+  newproperty(:syncversion) do
+
+    desc "If set to `true`, the policy will be reloaded if the
+    version found in the on-disk file differs from the loaded
+    version.  If set to `false` (the default) the only check
+    that will be made is if the policy is loaded at all or not."
+
+    newvalue(:true)
+    newvalue(:false)
+  end
+
+  autorequire(:file) do
+    if self[:selmodulepath]
+      [self[:selmodulepath]]
+    else
+      ["#{self[:selmoduledir]}/#{self[:name]}.pp"]
+    end
+  end
+end

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

@@ -0,0 +1,258 @@
+# 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
+
+  Type.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. As a last resort, Puppet will attempt to
+      search the process table by calling whatever command is listed in the `ps`
+      fact. The default search pattern is the name of the service, but you can
+      specify it with the `pattern` attribute.
+
+      **Refresh:** `service` resources can respond to refresh events (via
+      `notify`, `subscribe`, or the `~>` arrow). If a `service` receives an
+      event from another resource, Puppet will restart the service it manages.
+      The actual command used to restart the service depends on the platform and
+      can be configured:
+
+      * If you set `hasrestart` to true, Puppet will use the init script's restart command.
+      * You can provide an explicit command for restarting with the `restart` attribute.
+      * 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."
+
+    feature :flaggable, "The provider can pass flags to the service."
+
+    feature :maskable, "The provider can 'mask' the service.",
+      :methods => [:mask]
+
+    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
+
+      # This only makes sense on systemd systems. Otherwise, it just defaults
+      # to disable.
+      newvalue(:mask, :event => :service_disabled, :required_features => :maskable) do
+        provider.mask
+      end
+
+      def retrieve
+        provider.enabled?
+      end
+
+      # This only makes sense on systemd systems. Static services cannot be enabled
+      # or disabled manually.
+      def insync?(current)
+        if provider.respond_to?(:cached_enabled?) && provider.cached_enabled? == 'static'
+          Puppet.debug("Unable to enable or disable static service #{@resource[:name]}")
+          return true
+        end
+
+        super(current)
+      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, :invalidate_refreshes => true) 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
+
+    newproperty(:flags, :required_features => :flaggable) do
+      desc "Specify a string of flags to pass to the startup script."
+    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)
+        value.flatten.collect { |p| 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, including regular expressions (which should
+        be quoted without enclosing slashes)."
+
+      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.linuxfoundation.org/LSB_4.1.0/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 false."
+      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
+
+    def self.needs_ensure_retrieved
+      false
+    end
+  end
+end