puppet 3.5.0.rc1-x86-mingw32

data/lib/puppet/provider/parsedfile.rb

@@ -0,0 +1,443 @@
+require 'puppet'
+require 'puppet/util/filetype'
+require 'puppet/util/fileparsing'
+
+# This provider can be used as the parent class for a provider that
+# parses and generates files.  Its content must be loaded via the
+# 'prefetch' method, and the file will be written when 'flush' is called
+# on the provider instance.  At this point, the file is written once
+# for every provider instance.
+#
+# Once the provider prefetches the data, it's the resource's job to copy
+# that data over to the @is variables.
+class Puppet::Provider::ParsedFile < Puppet::Provider
+  extend Puppet::Util::FileParsing
+
+  class << self
+    attr_accessor :default_target, :target
+  end
+
+  attr_accessor :property_hash
+
+  def self.clean(hash)
+    newhash = hash.dup
+    [:record_type, :on_disk].each do |p|
+      newhash.delete(p) if newhash.include?(p)
+    end
+
+    newhash
+  end
+
+  def self.clear
+    @target_objects.clear
+    @records.clear
+  end
+
+  def self.filetype
+    @filetype ||= Puppet::Util::FileType.filetype(:flat)
+  end
+
+  def self.filetype=(type)
+    if type.is_a?(Class)
+      @filetype = type
+    elsif klass = Puppet::Util::FileType.filetype(type)
+      @filetype = klass
+    else
+      raise ArgumentError, "Invalid filetype #{type}"
+    end
+  end
+
+  # Flush all of the targets for which there are modified records.  The only
+  # reason we pass a record here is so that we can add it to the stack if
+  # necessary -- it's passed from the instance calling 'flush'.
+  def self.flush(record)
+    # Make sure this record is on the list to be flushed.
+    unless record[:on_disk]
+      record[:on_disk] = true
+      @records << record
+
+      # If we've just added the record, then make sure our
+      # target will get flushed.
+      modified(record[:target] || default_target)
+    end
+
+    return unless defined?(@modified) and ! @modified.empty?
+
+    flushed = []
+    begin
+      @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
+        Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
+        flushed << target
+        flush_target(target)
+      end
+    ensure
+      @modified.reject! { |t| flushed.include?(t) }
+    end
+  end
+
+  # Make sure our file is backed up, but only back it up once per transaction.
+  # We cheat and rely on the fact that @records is created on each prefetch.
+  def self.backup_target(target)
+    return nil unless target_object(target).respond_to?(:backup)
+
+    @backup_stats ||= {}
+    return nil if @backup_stats[target] == @records.object_id
+
+    target_object(target).backup
+    @backup_stats[target] = @records.object_id
+  end
+
+  # Flush all of the records relating to a specific target.
+  def self.flush_target(target)
+    backup_target(target)
+
+    records = target_records(target).reject { |r|
+      r[:ensure] == :absent
+    }
+
+    target_object(target).write(to_file(records))
+  end
+
+  # Return the header placed at the top of each generated file, warning
+  # users that modifying this file manually is probably a bad idea.
+  def self.header
+%{# HEADER: This file was autogenerated at #{Time.now}
+# HEADER: by puppet.  While it can still be managed manually, it
+# HEADER: is definitely not recommended.\n}
+  end
+
+  # An optional regular expression matched by third party headers.
+  #
+  # For example, this can be used to filter the vixie cron headers as
+  # erronously exported by older cron versions.
+  #
+  # @api private
+  # @abstract Providers based on ParsedFile may implement this to make it
+  #   possible to identify a header maintained by a third party tool.
+  #   The provider can then allow that header to remain near the top of the
+  #   written file, or remove it after composing the file content.
+  #   If implemented, the function must return a Regexp object.
+  #   The expression must be tailored to match exactly one third party header.
+  # @see drop_native_header
+  # @note When specifying regular expressions in multiline mode, avoid
+  #   greedy repititions such as '.*' (use .*? instead). Otherwise, the
+  #   provider may drop file content between sparse headers.
+  def self.native_header_regex
+    nil
+  end
+
+  # How to handle third party headers.
+  # @api private
+  # @abstract Providers based on ParsedFile that make use of the support for
+  #   third party headers may override this method to return +true+.
+  #   When this is done, headers that are matched by the native_header_regex
+  #   are not written back to disk.
+  # @see native_header_regex
+  def self.drop_native_header
+    false
+  end
+
+  # Add another type var.
+  def self.initvars
+    @records = []
+    @target_objects = {}
+
+    @target = nil
+
+    # Default to flat files
+    @filetype ||= Puppet::Util::FileType.filetype(:flat)
+    super
+  end
+
+  # Return a list of all of the records we can find.
+  def self.instances
+    targets.collect do |target|
+      prefetch_target(target)
+    end.flatten.reject { |r| skip_record?(r) }.collect do |record|
+      new(record)
+    end
+  end
+
+  # Override the default method with a lot more functionality.
+  def self.mk_resource_methods
+    [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
+      attr = attr.intern
+      define_method(attr) do
+        # If it's not a valid field for this record type (which can happen
+        # when different platforms support different fields), then just
+        # return the should value, so the resource shuts up.
+        if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
+          @property_hash[attr] || :absent
+        else
+          if defined?(@resource)
+            @resource.should(attr)
+          else
+            nil
+          end
+        end
+      end
+
+      define_method(attr.to_s + "=") do |val|
+        mark_target_modified
+        @property_hash[attr] = val
+      end
+    end
+  end
+
+  # Always make the resource methods.
+  def self.resource_type=(resource)
+    super
+    mk_resource_methods
+  end
+
+  # Mark a target as modified so we know to flush it.  This only gets
+  # used within the attr= methods.
+  def self.modified(target)
+    @modified ||= []
+    @modified << target unless @modified.include?(target)
+  end
+
+  # Retrieve all of the data from disk.  There are three ways to know
+  # which files to retrieve:  We might have a list of file objects already
+  # set up, there might be instances of our associated resource and they
+  # will have a path parameter set, and we will have a default path
+  # set.  We need to turn those three locations into a list of files,
+  # prefetch each one, and make sure they're associated with each appropriate
+  # resource instance.
+  def self.prefetch(resources = nil)
+    # Reset the record list.
+    @records = prefetch_all_targets(resources)
+
+    match_providers_with_resources(resources)
+  end
+
+  # Match a list of catalog resources with provider instances
+  #
+  # @api private
+  #
+  # @param [Array<Puppet::Resource>] resources A list of resources using this class as a provider
+  def self.match_providers_with_resources(resources)
+    return unless resources
+    matchers = resources.dup
+    @records.each do |record|
+      # Skip things like comments and blank lines
+      next if skip_record?(record)
+
+      if (resource = resource_for_record(record, resources))
+        resource.provider = new(record)
+      elsif respond_to?(:match)
+        if resource = match(record, matchers)
+          matchers.delete(resource.title)
+          record[:name] = resource[:name]
+          resource.provider = new(record)
+        end
+      end
+    end
+  end
+
+  # Look up a resource based on a parsed file record
+  #
+  # @api private
+  #
+  # @param [Hash<Symbol, Object>] record
+  # @param [Array<Puppet::Resource>] resources
+  #
+  # @return [Puppet::Resource, nil] The resource if found, else nil
+  def self.resource_for_record(record, resources)
+    name = record[:name]
+    if name
+      resources[name]
+    end
+  end
+
+  def self.prefetch_all_targets(resources)
+    records = []
+    targets(resources).each do |target|
+      records += prefetch_target(target)
+    end
+    records
+  end
+
+  # Prefetch an individual target.
+  def self.prefetch_target(target)
+
+    begin
+      target_records = retrieve(target)
+    rescue Puppet::Util::FileType::FileReadError => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Could not prefetch #{self.resource_type.name} provider '#{self.name}' target '#{target}': #{detail}. Treating as empty"
+      target_records = []
+    end
+
+    target_records.each do |r|
+      r[:on_disk] = true
+      r[:target] = target
+      r[:ensure] = :present
+    end
+
+    target_records = prefetch_hook(target_records) if respond_to?(:prefetch_hook)
+
+    raise Puppet::DevError, "Prefetching #{target} for provider #{self.name} returned nil" unless target_records
+
+    target_records
+  end
+
+  # Is there an existing record with this name?
+  def self.record?(name)
+    return nil unless @records
+    @records.find { |r| r[:name] == name }
+  end
+
+  # Retrieve the text for the file. Returns nil in the unlikely
+  # event that it doesn't exist.
+  def self.retrieve(path)
+    # XXX We need to be doing something special here in case of failure.
+    text = target_object(path).read
+    if text.nil? or text == ""
+      # there is no file
+      return []
+    else
+      # Set the target, for logging.
+      old = @target
+      begin
+        @target = path
+        return self.parse(text)
+      rescue Puppet::Error => detail
+        detail.file = @target if detail.respond_to?(:file=)
+        raise detail
+      ensure
+        @target = old
+      end
+    end
+  end
+
+  # Should we skip the record?  Basically, we skip text records.
+  # This is only here so subclasses can override it.
+  def self.skip_record?(record)
+    record_type(record[:record_type]).text?
+  end
+
+  # Initialize the object if necessary.
+  def self.target_object(target)
+    @target_objects[target] ||= filetype.new(target)
+
+    @target_objects[target]
+  end
+
+  # Find all of the records for a given target
+  def self.target_records(target)
+    @records.find_all { |r| r[:target] == target }
+  end
+
+  # Find a list of all of the targets that we should be reading.  This is
+  # used to figure out what targets we need to prefetch.
+  def self.targets(resources = nil)
+    targets = []
+    # First get the default target
+    raise Puppet::DevError, "Parsed Providers must define a default target" unless self.default_target
+    targets << self.default_target
+
+    # Then get each of the file objects
+    targets += @target_objects.keys
+
+    # Lastly, check the file from any resource instances
+    if resources
+      resources.each do |name, resource|
+        if value = resource.should(:target)
+          targets << value
+        end
+      end
+    end
+
+    targets.uniq.compact
+  end
+
+  # Compose file contents from the set of records.
+  #
+  # If self.native_header_regex is not nil, possible vendor headers are
+  # identified by matching the return value against the expression.
+  # If one (or several consecutive) such headers, are found, they are
+  # either moved in front of the self.header if self.drop_native_header
+  # is false (this is the default), or removed from the return value otherwise.
+  #
+  # @api private
+  def self.to_file(records)
+    text = super
+    if native_header_regex and (match = text.match(native_header_regex))
+      if drop_native_header
+        # concatenate the text in front of and after the native header
+        text = match.pre_match + match.post_match
+      else
+        native_header = match[0]
+        return native_header + header + match.pre_match + match.post_match
+      end
+    end
+    header + text
+  end
+
+  def create
+    @resource.class.validproperties.each do |property|
+      if value = @resource.should(property)
+        @property_hash[property] = value
+      end
+    end
+    mark_target_modified
+    (@resource.class.name.to_s + "_created").intern
+  end
+
+  def destroy
+    # We use the method here so it marks the target as modified.
+    self.ensure = :absent
+    (@resource.class.name.to_s + "_deleted").intern
+  end
+
+  def exists?
+    !(@property_hash[:ensure] == :absent or @property_hash[:ensure].nil?)
+  end
+
+  # Write our data to disk.
+  def flush
+    # Make sure we've got a target and name set.
+
+    # If the target isn't set, then this is our first modification, so
+    # mark it for flushing.
+    unless @property_hash[:target]
+      @property_hash[:target] = @resource.should(:target) || self.class.default_target
+      self.class.modified(@property_hash[:target])
+    end
+    @resource.class.key_attributes.each do |attr|
+      @property_hash[attr] ||= @resource[attr]
+    end
+
+    self.class.flush(@property_hash)
+  end
+
+  def initialize(record)
+    super
+
+    # The 'record' could be a resource or a record, depending on how the provider
+    # is initialized.  If we got an empty property hash (probably because the resource
+    # is just being initialized), then we want to set up some defaults.
+    @property_hash = self.class.record?(resource[:name]) || {:record_type => self.class.name, :ensure => :absent} if @property_hash.empty?
+  end
+
+  # Retrieve the current state from disk.
+  def prefetch
+    raise Puppet::DevError, "Somehow got told to prefetch with no resource set" unless @resource
+    self.class.prefetch(@resource[:name] => @resource)
+  end
+
+  def record_type
+    @property_hash[:record_type]
+  end
+
+  private
+
+  # Mark both the resource and provider target as modified.
+  def mark_target_modified
+    if defined?(@resource) and restarget = @resource.should(:target) and restarget != @property_hash[:target]
+      self.class.modified(restarget)
+    end
+    self.class.modified(@property_hash[:target]) if @property_hash[:target] != :absent and @property_hash[:target]
+  end
+end

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

@@ -0,0 +1,565 @@
+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 %q{This provider uses the win32-taskscheduler gem to manage scheduled
+    tasks on Windows.
+
+    Puppet requires version 0.2.1 or later of the win32-taskscheduler gem;
+    previous versions can cause "Could not evaluate: The operation completed
+    successfully" errors.}
+
+  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
+                  # 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::Windows::Security.name_to_sid(current) == Puppet::Util::Windows::Security.name_to_sid(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::Windows::Security.name_to_sid(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
+      @task = nil
+    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