puppet 2.7.6 → 2.7.8

data/lib/puppet/property.rb

@@ -100,11 +100,11 @@ class Puppet::Property < Puppet::Parameter
   def change_to_s(current_value, newvalue)
     begin
       if current_value == :absent
-        return "defined '#{name}' as '#{should_to_s(newvalue)}'"
+        return "defined '#{name}' as #{self.class.format_value_for_display should_to_s(newvalue)}"
       elsif newvalue == :absent or newvalue == [:absent]
-        return "undefined '#{name}' from '#{is_to_s(current_value)}'"
+        return "undefined '#{name}' from #{self.class.format_value_for_display is_to_s(current_value)}"
       else
-        return "#{name} changed '#{is_to_s(current_value)}' to '#{should_to_s(newvalue)}'"
+        return "#{name} changed #{self.class.format_value_for_display is_to_s(current_value)} to #{self.class.format_value_for_display should_to_s(newvalue)}"
       end
     rescue Puppet::Error, Puppet::DevError
       raise

data/lib/puppet/provider/augeas/augeas.rb

@@ -298,7 +298,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             saved_files.each do |key|
               saved_file = @aug.get(key).to_s.sub(/^\/files/, root)
               if Puppet[:show_diff]
-                print diff(saved_file, saved_file + ".augnew")
+                notice "\n" + diff(saved_file, saved_file + ".augnew")
               end
               if resource.noop?
                 File.delete(saved_file + ".augnew")

data/lib/puppet/provider/exec/windows.rb

@@ -3,8 +3,8 @@ require 'puppet/provider/exec'
 Puppet::Type.type(:exec).provide :windows, :parent => Puppet::Provider::Exec do
   include Puppet::Util::Execution
 
-  confine :feature => :microsoft_windows
-  defaultfor :feature => :microsoft_windows
+  confine    :operatingsystem => :windows
+  defaultfor :operatingsystem => :windows
 
   desc "Execute external binaries directly, on Windows systems.
 This does not pass through a shell, or perform any interpolation, but
@@ -23,11 +23,10 @@ only directly calls the command with the arguments given."
       return
     end
 
-    path = resource[:path] || []
-
-    exts = [".exe", ".ps1", ".bat", ".com", ""]
-    withenv :PATH => path.join(File::PATH_SEPARATOR) do
-      return if exts.any? {|ext| which(exe + ext) }
+    if resource[:path]
+      withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
+        return if which(exe)
+      end
     end
 
     raise ArgumentError, "Could not find command '#{exe}'"

data/lib/puppet/provider/file/windows.rb

@@ -1,7 +1,7 @@
 Puppet::Type.type(:file).provide :windows do
   desc "Uses Microsoft Windows functionality to manage file's users and rights."
 
-  confine :feature => :microsoft_windows
+  confine :operatingsystem => :windows
 
   include Puppet::Util::Warnings
 
@@ -81,7 +81,8 @@ Puppet::Type.type(:file).provide :windows do
 
   def mode
     if resource.exist?
-      get_mode(resource[:path]).to_s(8)
+      mode = get_mode(resource[:path])
+      mode ? mode.to_s(8) : :absent
     else
       :absent
     end
@@ -97,4 +98,10 @@ Puppet::Type.type(:file).provide :windows do
     end
     :file_changed
   end
+
+  def validate
+    if [:owner, :group, :mode].any?{|p| resource[p]} and !supports_acl?(resource[:path])
+      resource.fail("Can only manage owner, group, and mode on filesystems that support Windows ACLs, such as NTFS")
+    end
+  end
 end

data/lib/puppet/provider/group/aix.rb

@@ -3,11 +3,11 @@
 #  mkgroup, rmgroup, lsgroup, chgroup
 #
 # Author::    Hector Rivas Gandara <keymon@gmail.com>
-#  
+#
 require 'puppet/provider/aixobject'
 
 Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject do
-  desc "Group management for AIX! Users are managed with mkgroup, rmgroup, lsgroup, chgroup"
+  desc "Group management for AIX."
 
   # This will the the default provider for this platform
   defaultfor :operatingsystem => :aix
@@ -29,7 +29,7 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
   end
 
   # AIX attributes to properties mapping.
-  # 
+  #
   # Valid attributes to be managed by this provider.
   # It is a list with of hash
   #  :aix_attr      AIX command attribute name
@@ -43,10 +43,10 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
       :from => :users_from_attr},
     {:aix_attr => :attributes, :puppet_prop => :attributes},
   ]
-  
+
   #--------------
   # Command definition
-  
+
   # Return the IA module arguments based on the resource param ia_load_module
   def get_ia_module_args
     if @resource[:ia_load_module]
@@ -55,7 +55,7 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
       []
     end
   end
-  
+
   def lscmd(value=@resource[:name])
     [self.class.command(:list)] +
       self.get_ia_module_args +
@@ -80,7 +80,7 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
   def modifycmd(hash = property_hash)
     args = self.hash2args(hash)
     return nil if args.empty?
-    
+
     [self.class.command(:modify)] +
       self.get_ia_module_args +
       args + [@resource[:name]]
@@ -123,7 +123,7 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
     #self.class.validate(param, value)
     param = :attributes
     cmd = modifycmd({param => filter_attributes(attr_hash)})
-    if cmd 
+    if cmd
       begin
         execute(cmd)
       rescue Puppet::ExecutionFailure  => detail

data/lib/puppet/provider/group/groupadd.rb

@@ -1,9 +1,7 @@
 require 'puppet/provider/nameservice/objectadd'
 
 Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameService::ObjectAdd do
-  desc "Group management via `groupadd` and its ilk.
-
-  The default for most platforms
+  desc "Group management via `groupadd` and its ilk. The default for most platforms.
 
   "
 

data/lib/puppet/provider/group/ldap.rb

@@ -1,18 +1,16 @@
 require 'puppet/provider/ldap'
 
 Puppet::Type.type(:group).provide :ldap, :parent => Puppet::Provider::Ldap do
-  desc "Group management via `ldap`.
+  desc "Group management via LDAP.
 
-  This provider requires that you have valid values for all of the
-  ldap-related settings, including `ldapbase`.  You will also almost
-  definitely need settings for `ldapuser` and `ldappassword`, so that
-  your clients can write to ldap.
+    This provider requires that you have valid values for all of the
+    LDAP-related settings in `puppet.conf`, including `ldapbase`.  You will
+    almost definitely need settings for `ldapuser` and `ldappassword` in order
+    for your clients to write to LDAP.
 
-  Note that this provider will automatically generate a GID for you if you do
-  not specify one, but it is a potentially expensive operation, as it
-  iterates across all existing groups to pick the appropriate next one.
-
-  "
+    Note that this provider will automatically generate a GID for you if you do
+    not specify one, but it is a potentially expensive operation, as it
+    iterates across all existing groups to pick the appropriate next one."
 
   confine :true => Puppet.features.ldap?, :false => (Puppet[:ldapuser] == "")
 

data/lib/puppet/provider/group/windows_adsi.rb

@@ -4,8 +4,7 @@ Puppet::Type.type(:group).provide :windows_adsi do
   desc "Group management for Windows"
 
   defaultfor :operatingsystem => :windows
-  confine :operatingsystem => :windows
-  confine :feature => :microsoft_windows
+  confine    :operatingsystem => :windows
 
   has_features :manages_members
 
@@ -23,6 +22,8 @@ Puppet::Type.type(:group).provide :windows_adsi do
 
   def create
     @group = Puppet::Util::ADSI::Group.create(@resource[:name])
+    @group.commit
+
     self.members = @resource[:members]
   end
 
@@ -34,6 +35,11 @@ Puppet::Type.type(:group).provide :windows_adsi do
     Puppet::Util::ADSI::Group.delete(@resource[:name])
   end
 
+  # Only flush if we created or modified a group, not deleted
+  def flush
+    @group.commit if @group
+  end
+
   def gid
     Puppet::Util::ADSI.sid_for_account(@resource[:name])
   end

data/lib/puppet/provider/package/aix.rb

@@ -2,7 +2,7 @@ require 'puppet/provider/package'
 require 'puppet/util/package'
 
 Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package do
-  desc "Installation from AIX Software directory"
+  desc "Installation from the AIX software directory."
 
   # The commands we are using on an AIX box are installed standard
   # (except nimclient) nimclient needs the bos.sysmgt.nim.client fileset.

data/lib/puppet/provider/package/macports.rb

@@ -4,10 +4,10 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
   desc "Package management using MacPorts on OS X.
 
     Supports MacPorts versions and revisions, but not variants.
-    Variant preferences may be specified using the MacPorts variants.conf file
-    http://guide.macports.org/chunked/internals.configuration-files.html#internals.configuration-files.variants-conf
+    Variant preferences may be specified using
+    [the MacPorts variants.conf file](http://guide.macports.org/chunked/internals.configuration-files.html#internals.configuration-files.variants-conf).
 
-    When specifying a version in the Puppet DSL, only specify the version, not the revision
+    When specifying a version in the Puppet DSL, only specify the version, not the revision.
     Revisions are only used internally for ensuring the latest version/revision of a port.
   "
 

data/lib/puppet/provider/package/msi.rb

@@ -38,32 +38,39 @@ Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package)
     # Unfortunately, we can't use the msiexec method defined earlier,
     # because of the special quoting we need to do around the MSI
     # properties to use.
-    execute ['msiexec.exe', '/qn', '/norestart', '/i', shell_quote(resource[:source]), properties_for_command].flatten.compact.join(' ')
+    execute ['msiexec.exe', '/qn', '/norestart', '/i', shell_quote(msi_source), properties_for_command].flatten.compact.join(' ')
 
     File.open(state_file, 'w') do |f|
       metadata = {
         'name'            => resource[:name],
         'install_options' => resource[:install_options],
-        'source'          => resource[:source]
+        'source'          => msi_source
       }
 
-      f.puts(YAML.dump metadata)
+      f.puts(YAML.dump(metadata))
     end
   end
 
   def uninstall
-    msiexec '/qn', '/norestart', '/x', resource[:source]
+    msiexec '/qn', '/norestart', '/x', msi_source
 
     File.delete state_file
   end
 
   def validate_source(value)
-    fail("The source parameter is required when using the MSI provider.") if value.nil?
     fail("The source parameter cannot be empty when using the MSI provider.") if value.empty?
   end
 
   private
 
+  def msi_source
+    resource[:source] ||= YAML.load_file(state_file)['source'] rescue nil
+
+    fail("The source parameter is required when using the MSI provider.") unless resource[:source]
+
+    resource[:source]
+  end
+
   def self.installed_listing_dir
     listing_dir = File.join(Puppet[:vardir], 'db', 'package', 'msi')
 

data/lib/puppet/provider/package/nim.rb

@@ -2,7 +2,7 @@ require 'puppet/provider/package'
 require 'puppet/util/package'
 
 Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
-  desc "Installation from NIM LPP source"
+  desc "Installation from NIM LPP source."
 
   # The commands we are using on an AIX box are installed standard
   # (except nimclient) nimclient needs the bos.sysmgt.nim.client fileset.

data/lib/puppet/provider/package/pkgdmg.rb

@@ -15,9 +15,9 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   desc "Package management based on Apple's Installer.app and
     DiskUtility.app.  This package works by checking the contents of a
     DMG image for Apple pkg or mpkg files. Any number of pkg or mpkg
-    files may exist in the root directory of the DMG file system. Sub
-    directories are not checked for packages.  See `the wiki docs
-    <http://projects.puppetlabs.com/projects/puppet/wiki/Package_Management_With_Dmg_Patterns>`
+    files may exist in the root directory of the DMG file system.
+    Subdirectories are not checked for packages.  See
+    [the wiki docs on this provider](http://projects.puppetlabs.com/projects/puppet/wiki/Package_Management_With_Dmg_Patterns)
     for more detail."
 
   confine :operatingsystem => :darwin

data/lib/puppet/provider/package/ports.rb

@@ -1,5 +1,5 @@
 Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :freebsd do
-  desc "Support for FreeBSD's ports.  Again, this still mixes packages and ports."
+  desc "Support for FreeBSD's ports.  Note that this, too, mixes packages and ports."
 
   commands :portupgrade => "/usr/local/sbin/portupgrade",
     :portversion => "/usr/local/sbin/portversion",

data/lib/puppet/provider/scheduled_task/win32_taskscheduler.rb

@@ -0,0 +1,560 @@
+require 'puppet/parameter'
+
+if Puppet.features.microsoft_windows?
+  require 'win32/taskscheduler'
+  require 'puppet/util/adsi'
+end
+
+Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
+  desc 'This uses the win32-taskscheduler gem to provide support for
+    managing scheduled tasks on Windows.'
+
+  defaultfor :operatingsystem => :windows
+  confine    :operatingsystem => :windows
+
+  def self.instances
+    Win32::TaskScheduler.new.tasks.collect do |job_file|
+      job_title = File.basename(job_file, '.job')
+
+      new(
+        :provider => :win32_taskscheduler,
+        :name     => job_title
+      )
+    end
+  end
+
+  def exists?
+    Win32::TaskScheduler.new.exists? resource[:name]
+  end
+
+  def task
+    return @task if @task
+
+    @task ||= Win32::TaskScheduler.new
+    @task.activate(resource[:name] + '.job') if exists?
+
+    @task
+  end
+
+  def clear_task
+    @task       = nil
+    @triggers   = nil
+  end
+
+  def enabled
+    task.flags & Win32::TaskScheduler::DISABLED == 0 ? :true : :false
+  end
+
+  def command
+    task.application_name
+  end
+
+  def arguments
+    task.parameters
+  end
+
+  def working_dir
+    task.working_directory
+  end
+
+  def user
+    account = task.account_information
+    return 'system' if account == ''
+    account
+  end
+
+  def trigger
+    return @triggers if @triggers
+
+    @triggers   = []
+    task.trigger_count.times do |i|
+      trigger = begin
+                  task.trigger(i)
+                rescue Win32::TaskScheduler::Error => e
+                  # Win32::TaskScheduler can't handle all of the
+                  # trigger types Windows uses, so we need to skip the
+                  # unhandled types to prevent "puppet resource" from
+                  # blowing up.
+                  nil
+                end
+      next unless trigger and scheduler_trigger_types.include?(trigger['trigger_type'])
+
+      puppet_trigger = {}
+      case trigger['trigger_type']
+      when Win32::TaskScheduler::TASK_TIME_TRIGGER_DAILY
+        puppet_trigger['schedule'] = 'daily'
+        puppet_trigger['every']    = trigger['type']['days_interval'].to_s
+      when Win32::TaskScheduler::TASK_TIME_TRIGGER_WEEKLY
+        puppet_trigger['schedule'] = 'weekly'
+        puppet_trigger['every']    = trigger['type']['weeks_interval'].to_s
+        puppet_trigger['on']       = days_of_week_from_bitfield(trigger['type']['days_of_week'])
+      when Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDATE
+        puppet_trigger['schedule'] = 'monthly'
+        puppet_trigger['months']   = months_from_bitfield(trigger['type']['months'])
+        puppet_trigger['on']       = days_from_bitfield(trigger['type']['days'])
+      when Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDOW
+        puppet_trigger['schedule']         = 'monthly'
+        puppet_trigger['months']           = months_from_bitfield(trigger['type']['months'])
+        puppet_trigger['which_occurrence'] = occurrence_constant_to_name(trigger['type']['weeks'])
+        puppet_trigger['day_of_week']      = days_of_week_from_bitfield(trigger['type']['days_of_week'])
+      when Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE
+        puppet_trigger['schedule'] = 'once'
+      end
+      puppet_trigger['start_date'] = self.class.normalized_date("#{trigger['start_year']}-#{trigger['start_month']}-#{trigger['start_day']}")
+      puppet_trigger['start_time'] = self.class.normalized_time("#{trigger['start_hour']}:#{trigger['start_minute']}")
+      puppet_trigger['enabled']    = trigger['flags'] & Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED == 0
+      puppet_trigger['index']      = i
+
+      @triggers << puppet_trigger
+    end
+    @triggers = @triggers[0] if @triggers.length == 1
+
+    @triggers
+  end
+
+  def user_insync?(current, should)
+    return false unless current
+
+    # Win32::TaskScheduler can return the 'SYSTEM' account as the
+    # empty string.
+    current = 'system' if current == ''
+
+    # By comparing account SIDs we don't have to worry about case
+    # sensitivity, or canonicalization of the account name.
+    Puppet::Util::ADSI.sid_for_account(current) == Puppet::Util::ADSI.sid_for_account(should[0])
+  end
+
+  def trigger_insync?(current, should)
+    should  = [should] unless should.is_a?(Array)
+    current = [current] unless current.is_a?(Array)
+    return false unless current.length == should.length
+
+    current_in_sync = current.all? do |c|
+      should.any? {|s| triggers_same?(c, s)}
+    end
+
+    should_in_sync = should.all? do |s|
+      current.any? {|c| triggers_same?(c,s)}
+    end
+
+    current_in_sync && should_in_sync
+  end
+
+  def command=(value)
+    task.application_name = value
+  end
+
+  def arguments=(value)
+    task.parameters = value
+  end
+
+  def working_dir=(value)
+    task.working_directory = value
+  end
+
+  def enabled=(value)
+    if value == :true
+      task.flags = task.flags & ~Win32::TaskScheduler::DISABLED
+    else
+      task.flags = task.flags | Win32::TaskScheduler::DISABLED
+    end
+  end
+
+  def trigger=(value)
+    desired_triggers = value.is_a?(Array) ? value : [value]
+    current_triggers = trigger.is_a?(Array) ? trigger : [trigger]
+
+    extra_triggers = []
+    desired_to_search = desired_triggers.dup
+    current_triggers.each do |current|
+      if found = desired_to_search.find {|desired| triggers_same?(current, desired)}
+        desired_to_search.delete(found)
+      else
+        extra_triggers << current['index']
+      end
+    end
+
+    needed_triggers = []
+    current_to_search = current_triggers.dup
+    desired_triggers.each do |desired|
+      if found = current_to_search.find {|current| triggers_same?(current, desired)}
+        current_to_search.delete(found)
+      else
+        needed_triggers << desired
+      end
+    end
+
+    extra_triggers.reverse_each do |index|
+      task.delete_trigger(index)
+    end
+
+    needed_triggers.each do |trigger_hash|
+      # Even though this is an assignment, the API for
+      # Win32::TaskScheduler ends up appending this trigger to the
+      # list of triggers for the task, while #add_trigger is only able
+      # to replace existing triggers. *shrug*
+      task.trigger = translate_hash_to_trigger(trigger_hash)
+    end
+  end
+
+  def user=(value)
+    self.fail("Invalid user: #{value}") unless Puppet::Util::ADSI.sid_for_account(value)
+
+    if value.to_s.downcase != 'system'
+      task.set_account_information(value, resource[:password])
+    else
+      # Win32::TaskScheduler treats a nil/empty username & password as
+      # requesting the SYSTEM account.
+      task.set_account_information(nil, nil)
+    end
+  end
+
+  def create
+    clear_task
+    @task = Win32::TaskScheduler.new(resource[:name], dummy_time_trigger)
+
+    self.command = resource[:command]
+
+    [:arguments, :working_dir, :enabled, :trigger, :user].each do |prop|
+      send("#{prop}=", resource[prop]) if resource[prop]
+    end
+  end
+
+  def destroy
+    Win32::TaskScheduler.new.delete(resource[:name] + '.job')
+  end
+
+  def flush
+    unless resource[:ensure] == :absent
+      self.fail('Parameter command is required.') unless resource[:command]
+      task.save
+    end
+  end
+
+  def triggers_same?(current_trigger, desired_trigger)
+    return false unless current_trigger['schedule'] == desired_trigger['schedule']
+    return false if current_trigger.has_key?('enabled') && !current_trigger['enabled']
+
+    desired = desired_trigger.dup
+
+    desired['every']       ||= current_trigger['every']       if current_trigger.has_key?('every')
+    desired['months']      ||= current_trigger['months']      if current_trigger.has_key?('months')
+    desired['on']          ||= current_trigger['on']          if current_trigger.has_key?('on')
+    desired['day_of_week'] ||= current_trigger['day_of_week'] if current_trigger.has_key?('day_of_week')
+
+    translate_hash_to_trigger(current_trigger) == translate_hash_to_trigger(desired)
+  end
+
+  def self.normalized_date(date_string)
+    date = Date.parse("#{date_string}")
+    "#{date.year}-#{date.month}-#{date.day}"
+  end
+
+  def self.normalized_time(time_string)
+    Time.parse("#{time_string}").strftime('%H:%M')
+  end
+
+  def dummy_time_trigger
+    now = Time.now
+
+    {
+      'flags'                   => 0,
+      'random_minutes_interval' => 0,
+      'end_day'                 => 0,
+      "end_year"                => 0,
+      "trigger_type"            => 0,
+      "minutes_interval"        => 0,
+      "end_month"               => 0,
+      "minutes_duration"        => 0,
+      'start_year'              => now.year,
+      'start_month'             => now.month,
+      'start_day'               => now.day,
+      'start_hour'              => now.hour,
+      'start_minute'            => now.min,
+      'trigger_type'            => Win32::TaskScheduler::ONCE,
+    }
+  end
+
+  def translate_hash_to_trigger(puppet_trigger, user_provided_input=false)
+    trigger = dummy_time_trigger
+
+    if user_provided_input
+      self.fail "'enabled' is read-only on triggers" if puppet_trigger.has_key?('enabled')
+      self.fail "'index' is read-only on triggers"   if puppet_trigger.has_key?('index')
+    end
+    puppet_trigger.delete('index')
+
+    if puppet_trigger.delete('enabled') == false
+      trigger['flags'] |= Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED
+    else
+      trigger['flags'] &= ~Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED
+    end
+
+    extra_keys = puppet_trigger.keys.sort - ['schedule', 'start_date', 'start_time', 'every', 'months', 'on', 'which_occurrence', 'day_of_week']
+    self.fail "Unknown trigger option(s): #{Puppet::Parameter.format_value_for_display(extra_keys)}" unless extra_keys.empty?
+    self.fail "Must specify 'start_time' when defining a trigger" unless puppet_trigger['start_time']
+
+    case puppet_trigger['schedule']
+    when 'daily'
+      trigger['trigger_type'] = Win32::TaskScheduler::DAILY
+      trigger['type'] = {
+        'days_interval' => Integer(puppet_trigger['every'] || 1)
+      }
+    when 'weekly'
+      trigger['trigger_type'] = Win32::TaskScheduler::WEEKLY
+      trigger['type'] = {
+        'weeks_interval' => Integer(puppet_trigger['every'] || 1)
+      }
+
+      trigger['type']['days_of_week'] = if puppet_trigger['day_of_week']
+                                          bitfield_from_days_of_week(puppet_trigger['day_of_week'])
+                                        else
+                                          scheduler_days_of_week.inject(0) {|day_flags,day| day_flags |= day}
+                                        end
+    when 'monthly'
+      trigger['type'] = {
+        'months' => bitfield_from_months(puppet_trigger['months'] || (1..12).to_a),
+      }
+
+      if puppet_trigger.keys.include?('on')
+        if puppet_trigger.has_key?('day_of_week') or puppet_trigger.has_key?('which_occurrence')
+          self.fail "Neither 'day_of_week' nor 'which_occurrence' can be specified when creating a monthly date-based trigger"
+        end
+
+        trigger['trigger_type'] = Win32::TaskScheduler::MONTHLYDATE
+        trigger['type']['days'] = bitfield_from_days(puppet_trigger['on'])
+      elsif puppet_trigger.keys.include?('which_occurrence') or puppet_trigger.keys.include?('day_of_week')
+        self.fail 'which_occurrence cannot be specified as an array' if puppet_trigger['which_occurrence'].is_a?(Array)
+        %w{day_of_week which_occurrence}.each do |field|
+          self.fail "#{field} must be specified when creating a monthly day-of-week based trigger" unless puppet_trigger.has_key?(field)
+        end
+
+        trigger['trigger_type']         = Win32::TaskScheduler::MONTHLYDOW
+        trigger['type']['weeks']        = occurrence_name_to_constant(puppet_trigger['which_occurrence'])
+        trigger['type']['days_of_week'] = bitfield_from_days_of_week(puppet_trigger['day_of_week'])
+      else
+        self.fail "Don't know how to create a 'monthly' schedule with the options: #{puppet_trigger.keys.sort.join(', ')}"
+      end
+    when 'once'
+      self.fail "Must specify 'start_date' when defining a one-time trigger" unless puppet_trigger['start_date']
+
+      trigger['trigger_type'] = Win32::TaskScheduler::ONCE
+    else
+      self.fail "Unknown schedule type: #{puppet_trigger["schedule"].inspect}"
+    end
+
+    if start_date = puppet_trigger['start_date']
+      start_date = Date.parse(start_date)
+      self.fail "start_date must be on or after 1753-01-01" unless start_date >= Date.new(1753, 1, 1)
+
+      trigger['start_year']  = start_date.year
+      trigger['start_month'] = start_date.month
+      trigger['start_day']   = start_date.day
+    end
+
+    start_time = Time.parse(puppet_trigger['start_time'])
+    trigger['start_hour']   = start_time.hour
+    trigger['start_minute'] = start_time.min
+
+    trigger
+  end
+
+  def validate_trigger(value)
+    value = [value] unless value.is_a?(Array)
+
+    # translate_hash_to_trigger handles the same validation that we
+    # would be doing here at the individual trigger level.
+    value.each {|t| translate_hash_to_trigger(t, true)}
+
+    true
+  end
+
+  private
+
+  def bitfield_from_months(months)
+    bitfield = 0
+
+    months = [months] unless months.is_a?(Array)
+    months.each do |month|
+      integer_month = Integer(month) rescue nil
+      self.fail 'Month must be specified as an integer in the range 1-12' unless integer_month == month.to_f and integer_month.between?(1,12)
+
+      bitfield |= scheduler_months[integer_month - 1]
+    end
+
+    bitfield
+  end
+
+  def bitfield_from_days(days)
+    bitfield = 0
+
+    days = [days] unless days.is_a?(Array)
+    days.each do |day|
+      # The special "day" of 'last' is represented by day "number"
+      # 32. 'last' has the special meaning of "the last day of the
+      # month", no matter how many days there are in the month.
+      day = 32 if day == 'last'
+
+      integer_day = Integer(day)
+      self.fail "Day must be specified as an integer in the range 1-31, or as 'last'" unless integer_day = day.to_f and integer_day.between?(1,32)
+
+      bitfield |= 1 << integer_day - 1
+    end
+
+    bitfield
+  end
+
+  def bitfield_from_days_of_week(days_of_week)
+    bitfield = 0
+
+    days_of_week = [days_of_week] unless days_of_week.is_a?(Array)
+    days_of_week.each do |day_of_week|
+      bitfield |= day_of_week_name_to_constant(day_of_week)
+    end
+
+    bitfield
+  end
+
+  def months_from_bitfield(bitfield)
+    months = []
+
+    scheduler_months.each do |month|
+      if bitfield & month != 0
+        months << month_constant_to_number(month)
+      end
+    end
+
+    months
+  end
+
+  def days_from_bitfield(bitfield)
+    days = []
+
+    i = 0
+    while bitfield > 0
+      if bitfield & 1 > 0
+        # Day 32 has the special meaning of "the last day of the
+        # month", no matter how many days there are in the month.
+        days << (i == 31 ? 'last' : i + 1)
+      end
+
+      bitfield = bitfield >> 1
+      i += 1
+    end
+
+    days
+  end
+
+  def days_of_week_from_bitfield(bitfield)
+    days_of_week = []
+
+    scheduler_days_of_week.each do |day_of_week|
+      if bitfield & day_of_week != 0
+        days_of_week << day_of_week_constant_to_name(day_of_week)
+      end
+    end
+
+    days_of_week
+  end
+
+  def scheduler_trigger_types
+    [
+      Win32::TaskScheduler::TASK_TIME_TRIGGER_DAILY,
+      Win32::TaskScheduler::TASK_TIME_TRIGGER_WEEKLY,
+      Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDATE,
+      Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDOW,
+      Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE
+    ]
+  end
+
+  def scheduler_days_of_week
+    [
+      Win32::TaskScheduler::SUNDAY,
+      Win32::TaskScheduler::MONDAY,
+      Win32::TaskScheduler::TUESDAY,
+      Win32::TaskScheduler::WEDNESDAY,
+      Win32::TaskScheduler::THURSDAY,
+      Win32::TaskScheduler::FRIDAY,
+      Win32::TaskScheduler::SATURDAY
+    ]
+  end
+
+  def scheduler_months
+    [
+      Win32::TaskScheduler::JANUARY,
+      Win32::TaskScheduler::FEBRUARY,
+      Win32::TaskScheduler::MARCH,
+      Win32::TaskScheduler::APRIL,
+      Win32::TaskScheduler::MAY,
+      Win32::TaskScheduler::JUNE,
+      Win32::TaskScheduler::JULY,
+      Win32::TaskScheduler::AUGUST,
+      Win32::TaskScheduler::SEPTEMBER,
+      Win32::TaskScheduler::OCTOBER,
+      Win32::TaskScheduler::NOVEMBER,
+      Win32::TaskScheduler::DECEMBER
+    ]
+  end
+
+  def scheduler_occurrences
+    [
+      Win32::TaskScheduler::FIRST_WEEK,
+      Win32::TaskScheduler::SECOND_WEEK,
+      Win32::TaskScheduler::THIRD_WEEK,
+      Win32::TaskScheduler::FOURTH_WEEK,
+      Win32::TaskScheduler::LAST_WEEK
+    ]
+  end
+
+  def day_of_week_constant_to_name(constant)
+    case constant
+    when Win32::TaskScheduler::SUNDAY;    'sun'
+    when Win32::TaskScheduler::MONDAY;    'mon'
+    when Win32::TaskScheduler::TUESDAY;   'tues'
+    when Win32::TaskScheduler::WEDNESDAY; 'wed'
+    when Win32::TaskScheduler::THURSDAY;  'thurs'
+    when Win32::TaskScheduler::FRIDAY;    'fri'
+    when Win32::TaskScheduler::SATURDAY;  'sat'
+    end
+  end
+
+  def day_of_week_name_to_constant(name)
+    case name
+    when 'sun';   Win32::TaskScheduler::SUNDAY
+    when 'mon';   Win32::TaskScheduler::MONDAY
+    when 'tues';  Win32::TaskScheduler::TUESDAY
+    when 'wed';   Win32::TaskScheduler::WEDNESDAY
+    when 'thurs'; Win32::TaskScheduler::THURSDAY
+    when 'fri';   Win32::TaskScheduler::FRIDAY
+    when 'sat';   Win32::TaskScheduler::SATURDAY
+    end
+  end
+
+  def month_constant_to_number(constant)
+    month_num = 1
+    while constant >> month_num - 1 > 1
+      month_num += 1
+    end
+    month_num
+  end
+
+  def occurrence_constant_to_name(constant)
+    case constant
+    when Win32::TaskScheduler::FIRST_WEEK;  'first'
+    when Win32::TaskScheduler::SECOND_WEEK; 'second'
+    when Win32::TaskScheduler::THIRD_WEEK;  'third'
+    when Win32::TaskScheduler::FOURTH_WEEK; 'fourth'
+    when Win32::TaskScheduler::LAST_WEEK;   'last'
+    end
+  end
+
+  def occurrence_name_to_constant(name)
+    case name
+    when 'first';  Win32::TaskScheduler::FIRST_WEEK
+    when 'second'; Win32::TaskScheduler::SECOND_WEEK
+    when 'third';  Win32::TaskScheduler::THIRD_WEEK
+    when 'fourth'; Win32::TaskScheduler::FOURTH_WEEK
+    when 'last';   Win32::TaskScheduler::LAST_WEEK
+    end
+  end
+end