puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/lib/puppet/util/network_device/cisco/facts.rb

@@ -1,72 +0,0 @@
-
-require 'puppet/util/network_device/cisco'
-require 'puppet/util/network_device/ipcalc'
-
-# this retrieves facts from a cisco device
-class Puppet::Util::NetworkDevice::Cisco::Facts
-
-  attr_reader :transport
-
-  def initialize(transport)
-    @transport = transport
-  end
-
-  def retrieve
-    facts = {}
-    facts.merge(parse_show_ver)
-  end
-
-  def parse_show_ver
-    facts = {}
-    out = @transport.command("sh ver")
-    lines = out.split("\n")
-    lines.shift; lines.pop
-    lines.each do |l|
-      case l
-      # cisco WS-C2924C-XL (PowerPC403GA) processor (revision 0x11) with 8192K/1024K bytes of memory.
-      # Cisco 1841 (revision 5.0) with 355328K/37888K bytes of memory.
-      # Cisco 877 (MPC8272) processor (revision 0x200) with 118784K/12288K bytes of memory.
-      # cisco WS-C2960G-48TC-L (PowerPC405) processor (revision C0) with 61440K/4088K bytes of memory.
-      # cisco WS-C2950T-24 (RC32300) processor (revision R0) with 19959K bytes of memory.
-      when /[cC]isco ([\w-]+) (?:\(([\w-]+)\) processor )?\(revision (.+)\) with (\d+[KMG])(?:\/(\d+[KMG]))? bytes of memory\./
-        facts[:hardwaremodel] = $1
-        facts[:processor] = $2 if $2
-        facts[:hardwarerevision] = $3
-        facts[:memorysize] = $4
-      # uptime
-      # Switch uptime is 1 year, 12 weeks, 6 days, 22 hours, 32 minutes
-      # c2950 uptime is 3 weeks, 1 day, 23 hours, 36 minutes
-      # c2960 uptime is 2 years, 27 weeks, 5 days, 21 hours, 30 minutes
-      # router uptime is 5 weeks, 1 day, 3 hours, 30 minutes
-      when /^\s*([\w-]+)\s+uptime is (.*?)$/
-        facts[:hostname] = $1
-        facts[:uptime] = $2
-        facts[:uptime_seconds] = uptime_to_seconds($2)
-        facts[:uptime_days] = facts[:uptime_seconds] / 86400
-      # "IOS (tm) C2900XL Software (C2900XL-C3H2S-M), Version 12.0(5)WC10, RELEASE SOFTWARE (fc1)"=> { :operatingsystem => "IOS", :operatingsystemrelease => "12.0(5)WC10", :operatingsystemmajrelease => "12.0", :operatingsystemfeature => "C3H2S"},
-      # "IOS (tm) C2950 Software (C2950-I6K2L2Q4-M), Version 12.1(22)EA8a, RELEASE SOFTWARE (fc1)"=> { :operatingsystem => "IOS", :operatingsystemrelease => "12.1(22)EA8a", :operatingsystemmajrelease => "12.1", :operatingsystemfeature => "I6K2L2Q4"},
-      # "Cisco IOS Software, C2960 Software (C2960-LANBASEK9-M), Version 12.2(44)SE, RELEASE SOFTWARE (fc1)"=>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.2(44)SE", :operatingsystemmajrelease => "12.2", :operatingsystemfeature => "LANBASEK9"},
-      # "Cisco IOS Software, C870 Software (C870-ADVIPSERVICESK9-M), Version 12.4(11)XJ4, RELEASE SOFTWARE (fc2)"=>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.4(11)XJ40", :operatingsystemmajrelease => "12.4XJ", :operatingsystemfeature => "ADVIPSERVICESK9"},
-      # "Cisco IOS Software, 1841 Software (C1841-ADVSECURITYK9-M), Version 12.4(24)T4, RELEASE SOFTWARE (fc2)" =>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.4(24)T4", :operatingsystemmajrelease => "12.4T", :operatingsystemfeature => "ADVSECURITYK9"},
-      when /(?:Cisco )?(IOS)\s*(?:\(tm\) |Software, )?(?:\w+)\s+Software\s+\(\w+-(\w+)-\w+\), Version ([0-9.()A-Za-z]+),/
-        facts[:operatingsystem] = $1
-        facts[:operatingsystemrelease] = $3
-        facts[:operatingsystemmajrelease] = ios_major_version(facts[:operatingsystemrelease])
-        facts[:operatingsystemfeature] = $2
-      end
-    end
-    facts
-  end
-
-  def ios_major_version(version)
-    version.gsub(/^(\d+)\.(\d+)\(.+\)([A-Z]+)([\da-z]+)?/, '\1.\2\3')
-  end
-
-  def uptime_to_seconds(uptime)
-    captures = (uptime.match(/^(?:(\d+) years?,)?\s*(?:(\d+) weeks?,)?\s*(?:(\d+) days?,)?\s*(?:(\d+) hours?,)?\s*(\d+) minutes?$/)).captures
-    captures.zip([31536000, 604800, 86400, 3600, 60]).inject(0) do |total, (x,y)|
-      total + (x.nil? ? 0 : x.to_i * y)
-    end
-  end
-
-end

data/lib/puppet/util/network_device/cisco/interface.rb

@@ -1,94 +0,0 @@
-require 'puppet/util/network_device/cisco'
-require 'puppet/util/network_device/ipcalc'
-
-# this manages setting properties to an interface in a cisco switch or router
-class Puppet::Util::NetworkDevice::Cisco::Interface
-
-  include Puppet::Util::NetworkDevice::IPCalc
-  extend Puppet::Util::NetworkDevice::IPCalc
-
-  attr_reader :transport, :name
-
-  def initialize(name, transport)
-    @name = name
-    @transport = transport
-  end
-
-  COMMANDS = {
-    # property     => order, ios command/block/array
-    :description   => [1, "description %s"],
-    :speed         => [2, "speed %s"],
-    :duplex        => [3, "duplex %s"],
-    :encapsulation => [4, "switchport trunk encapsulation %s"],
-    :mode          => [5, "switchport mode %s"],
-    :access_vlan   => [6, "switchport access vlan %s"],
-    :native_vlan   => [7, "switchport trunk native vlan %s"],
-    :allowed_trunk_vlans => [8, "switchport trunk allowed vlan %s"],
-    :etherchannel  => [9, ["channel-group %s", "port group %s"]],
-    :ipaddress     => [10,
-      lambda do |prefix,ip,option|
-        ip.ipv6? ? "ipv6 address #{ip}/#{prefix} #{option}" :
-                   "ip address #{ip} #{netmask(Socket::AF_INET,prefix)}"
-      end],
-    :ensure        => [11, lambda { |value| value == :present ? "no shutdown" : "shutdown" } ]
-  }
-
-  def update(is={}, should={})
-    Puppet.debug("Updating interface #{name}")
-    command("conf t")
-    command("interface #{name}")
-
-    # apply changes in a defined order for cisco IOS devices
-    [is.keys, should.keys].flatten.uniq.sort {|a,b| COMMANDS[a][0] <=> COMMANDS[b][0] }.each do |property|
-      # Work around for old documentation which shows :native_vlan used for access vlan
-      if property == :access_vlan and should[:mode] != :trunk and should[:access_vlan].nil?
-        should[:access_vlan] = should[:native_vlan]
-      end
-
-      Puppet.debug("comparing #{property}: #{is[property]} == #{should[property]}")
-
-      # They're equal, so do nothing.
-      next if is[property] == should[property]
-
-      # We're deleting it
-      if should[property] == :absent or should[property].nil?
-        execute(property, is[property], "no ")
-        next
-      end
-
-      # We're replacing an existing value or creating a new one
-      execute(property, should[property])
-    end
-
-    command("exit")
-    command("exit")
-  end
-
-  def execute(property, value, prefix='')
-    case COMMANDS[property][1]
-    when Array
-      COMMANDS[property][1].each do |command|
-        transport.command(prefix + command % value) do |out|
-          break unless out =~ /^%/
-        end
-      end
-    when String
-      command(prefix + COMMANDS[property][1] % value)
-    when Proc
-      value = [value] unless value.is_a?(Array)
-      value.each do |v|
-        command(prefix + COMMANDS[property][1].call(*v))
-      end
-    end
-  end
-
-  def command(command)
-    transport.command(command) do |out|
-      if out =~ /^%/mo or out =~ /^Command rejected:/mo
-        # strip off the command just sent
-        error = out.sub(command,'')
-        Puppet.err _("Error while executing '%{command}', device returned: %{error}") % { command: command, error: error }
-      end
-    end
-  end
-end

data/lib/puppet/util/network_device/ipcalc.rb

@@ -1,68 +0,0 @@
-require 'puppet/util/network_device'
-
-module Puppet::Util::NetworkDevice::IPCalc
-
-  # This is a rip-off of authstore
-  Octet = '(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])'
-  IPv4 = "#{Octet}\.#{Octet}\.#{Octet}\.#{Octet}"
-  IPv6_full    = "_:_:_:_:_:_:_:_|_:_:_:_:_:_::_?|_:_:_:_:_::((_:)?_)?|_:_:_:_::((_:){0,2}_)?|_:_:_::((_:){0,3}_)?|_:_::((_:){0,4}_)?|_::((_:){0,5}_)?|::((_:){0,6}_)?"
-  IPv6_partial = "_:_:_:_:_:_:|_:_:_:_::(_:)?|_:_::(_:){0,2}|_::(_:){0,3}"
-  IP = "#{IPv4}|#{IPv6_full}".gsub(/_/,'([0-9a-fA-F]{1,4})').gsub(/\(/,'(?:')
-
-  def parse(value)
-    case value
-    when /^(#{IP})\/(\d+)$/  # 12.34.56.78/24, a001:b002::efff/120, c444:1000:2000::9:192.168.0.1/112
-      [$2.to_i,IPAddr.new($1)]
-    when /^(#{IP})$/           # 10.20.30.40,
-      value = IPAddr.new(value)
-      [bits(value.family),value]
-    end
-  end
-
-  def bits(family)
-    family == Socket::AF_INET6 ? 128 : 32
-  end
-
-  def fullmask(family)
-    (1 << bits(family)) - 1
-  end
-
-  def mask(family, length)
-    (1 << (bits(family) - length)) - 1
-  end
-
-  # returns ip address netmask from prefix length
-  def netmask(family, length)
-    IPAddr.new(fullmask(family) & ~mask(family, length) , family)
-  end
-
-  # returns an IOS wildmask
-  def wildmask(family, length)
-    IPAddr.new(mask(family, length) , family)
-  end
-
-  # returns ip address prefix length from netmask
-  def prefix_length(netmask)
-    mask_addr = netmask.to_i
-    return 0 if mask_addr == 0
-    length=32
-    if (netmask.ipv6?)
-      length=128
-    end
-
-    mask = mask_addr < 2**length ? length : 128
-
-    mask.times do
-        if ((mask_addr & 1) == 1)
-            break
-        end
-        mask_addr = mask_addr >> 1
-        mask = mask - 1
-    end
-    mask
-  end
-
-  def linklocal?(ip)
-  end
-
-end

data/lib/puppet/util/network_device/transport/ssh.rb

@@ -1,126 +0,0 @@
-
-require 'puppet/util/network_device'
-require 'puppet/util/network_device/transport'
-require 'puppet/util/network_device/transport/base'
-
-# This is an adaptation/simplification of gem net-ssh-telnet, which aims to have
-# a sane interface to Net::SSH. Credits goes to net-ssh-telnet authors
-class Puppet::Util::NetworkDevice::Transport::Ssh < Puppet::Util::NetworkDevice::Transport::Base
-
-  attr_accessor :buf, :ssh, :channel
-
-  def initialize(verbose = false)
-    super()
-    @verbose = verbose
-    unless Puppet.features.ssh?
-      raise _('Connecting with ssh to a network device requires the \'net/ssh\' ruby library')
-    end
-  end
-
-  def handles_login?
-    true
-  end
-
-  def eof?
-    !! @eof
-  end
-
-  def connect(&block)
-    @output = []
-    @channel_data = ""
-
-    begin
-      Puppet.debug("connecting to #{host} as #{user}")
-      @ssh = Net::SSH.start(host, user, :port => port, :password => password, :timeout => timeout)
-    rescue TimeoutError
-      raise TimeoutError, _("timed out while opening an ssh connection to the host"), $!.backtrace
-    rescue Net::SSH::AuthenticationFailed
-      raise Puppet::Error, _("SSH authentication failure connecting to %{host} as %{user}") % { host: host, user: user }, $!.backtrace
-    rescue Net::SSH::Exception
-      raise Puppet::Error, _("SSH connection failure to %{host}") % { host: host }, $!.backtrace
-    end
-
-    @buf = ""
-    @eof = false
-    @channel = nil
-    @ssh.open_channel do |channel|
-      channel.request_pty { |ch,success| raise _("failed to open pty") unless success }
-
-      channel.send_channel_request("shell") do |ch, success|
-        raise _("failed to open ssh shell channel") unless success
-
-        ch.on_data { |_,data| @buf << data }
-        ch.on_extended_data { |_,type,data|  @buf << data if type == 1 }
-        ch.on_close { @eof = true }
-
-        @channel = ch
-        expect(default_prompt, &block)
-        # this is a little bit unorthodox, we're trying to escape
-        # the ssh loop there while still having the ssh connection up
-        # otherwise we wouldn't be able to return ssh stdout/stderr
-        # for a given call of command.
-        return # rubocop:disable Lint/NonLocalExitFromIterator
-      end
-
-    end
-    @ssh.loop
-
-  end
-
-  def close
-    begin
-      @channel.close if @channel
-      @channel = nil
-      @ssh.close if @ssh
-    rescue IOError
-      Puppet.debug "device terminated ssh session impolitely"
-    end
-  end
-
-  def expect(prompt)
-    line = ''
-    sock = @ssh.transport.socket
-
-    while not @eof
-      break if line =~ prompt and @buf == ''
-      break if sock.closed?
-
-      IO::select([sock], [sock], nil, nil)
-
-      process_ssh
-
-      # at this point we have accumulated some data in @buf
-      # or the channel has been closed
-      if @buf != ""
-        line += @buf.gsub(/\r\n/no, "\n")
-        @buf = ''
-        yield line if block_given?
-      elsif @eof
-        # channel has been closed
-        break if line =~ prompt
-        if line == ''
-          line = nil
-          yield nil if block_given?
-        end
-        break
-      end
-    end
-    Puppet.debug("ssh: expected #{line}") if @verbose
-    line
-  end
-
-  def send(line)
-    Puppet.debug("ssh: send #{line}") if @verbose
-    @channel.send_data(line + "\n")
-  end
-
-  def process_ssh
-    while @buf == "" and not eof?
-      begin
-        @channel.connection.process(0.1)
-      rescue IOError
-        @eof = true
-      end
-    end
-  end
-end

data/lib/puppet/util/network_device/transport/telnet.rb

@@ -1,47 +0,0 @@
-require 'puppet/util/network_device'
-require 'puppet/util/network_device/transport'
-require 'puppet/util/network_device/transport/base'
-
-if Puppet.features.telnet?
-  require 'net/telnet'
-
-  class Puppet::Util::NetworkDevice::Transport::Telnet < Puppet::Util::NetworkDevice::Transport::Base
-      def initialize(verbose = false)
-        super()
-        @verbose = verbose
-      end
-
-      def handles_login?
-        false
-      end
-
-      def connect
-        @telnet = Net::Telnet::new("Host" => host, "Port" => port || 23,
-                                   "Timeout" => 10,
-                                   "Prompt" => default_prompt)
-      end
-
-      def close
-        @telnet.close if @telnet
-        @telnet = nil
-      end
-
-      def expect(prompt)
-        @telnet.waitfor(prompt) do |out|
-          yield out if block_given?
-        end
-      end
-
-      def command(cmd, options = {})
-        send(cmd)
-        expect(options[:prompt] || default_prompt) do |output|
-          yield output if block_given?
-        end
-      end
-
-      def send(line)
-        Puppet.debug("telnet: send #{line}") if @verbose
-        @telnet.puts(line)
-      end
-  end
-end

data/lib/puppet/util/windows/taskscheduler.rb

@@ -1,1267 +0,0 @@
-require 'puppet/util/windows'
-
-# The Win32 module serves as a namespace only
-module Win32
-  # The TaskScheduler class encapsulates taskscheduler settings and behavior
-  class TaskScheduler
-    include Puppet::Util::Windows::String
-
-    require 'ffi'
-    extend FFI::Library
-
-    # The error class raised if any task scheduler specific calls fail.
-    class Error < Puppet::Util::Windows::Error; end
-
-    class << self
-      attr_accessor :com_initialized
-    end
-
-    # :stopdoc:
-    TASK_TIME_TRIGGER_ONCE            = :TASK_TIME_TRIGGER_ONCE
-    TASK_TIME_TRIGGER_DAILY           = :TASK_TIME_TRIGGER_DAILY
-    TASK_TIME_TRIGGER_WEEKLY          = :TASK_TIME_TRIGGER_WEEKLY
-    TASK_TIME_TRIGGER_MONTHLYDATE     = :TASK_TIME_TRIGGER_MONTHLYDATE
-    TASK_TIME_TRIGGER_MONTHLYDOW      = :TASK_TIME_TRIGGER_MONTHLYDOW
-    TASK_EVENT_TRIGGER_ON_IDLE        = :TASK_EVENT_TRIGGER_ON_IDLE
-    TASK_EVENT_TRIGGER_AT_SYSTEMSTART = :TASK_EVENT_TRIGGER_AT_SYSTEMSTART
-    TASK_EVENT_TRIGGER_AT_LOGON       = :TASK_EVENT_TRIGGER_AT_LOGON
-
-    TASK_SUNDAY       = 0x1
-    TASK_MONDAY       = 0x2
-    TASK_TUESDAY      = 0x4
-    TASK_WEDNESDAY    = 0x8
-    TASK_THURSDAY     = 0x10
-    TASK_FRIDAY       = 0x20
-    TASK_SATURDAY     = 0x40
-    TASK_FIRST_WEEK   = 1
-    TASK_SECOND_WEEK  = 2
-    TASK_THIRD_WEEK   = 3
-    TASK_FOURTH_WEEK  = 4
-    TASK_LAST_WEEK    = 5
-    TASK_JANUARY      = 0x1
-    TASK_FEBRUARY     = 0x2
-    TASK_MARCH        = 0x4
-    TASK_APRIL        = 0x8
-    TASK_MAY          = 0x10
-    TASK_JUNE         = 0x20
-    TASK_JULY         = 0x40
-    TASK_AUGUST       = 0x80
-    TASK_SEPTEMBER    = 0x100
-    TASK_OCTOBER      = 0x200
-    TASK_NOVEMBER     = 0x400
-    TASK_DECEMBER     = 0x800
-
-    TASK_FLAG_INTERACTIVE                  = 0x1
-    TASK_FLAG_DELETE_WHEN_DONE             = 0x2
-    TASK_FLAG_DISABLED                     = 0x4
-    TASK_FLAG_START_ONLY_IF_IDLE           = 0x10
-    TASK_FLAG_KILL_ON_IDLE_END             = 0x20
-    TASK_FLAG_DONT_START_IF_ON_BATTERIES   = 0x40
-    TASK_FLAG_KILL_IF_GOING_ON_BATTERIES   = 0x80
-    TASK_FLAG_RUN_ONLY_IF_DOCKED           = 0x100
-    TASK_FLAG_HIDDEN                       = 0x200
-    TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET = 0x400
-    TASK_FLAG_RESTART_ON_IDLE_RESUME       = 0x800
-    TASK_FLAG_SYSTEM_REQUIRED              = 0x1000
-    TASK_FLAG_RUN_ONLY_IF_LOGGED_ON        = 0x2000
-    TASK_TRIGGER_FLAG_HAS_END_DATE         = 0x1
-    TASK_TRIGGER_FLAG_KILL_AT_DURATION_END = 0x2
-    TASK_TRIGGER_FLAG_DISABLED             = 0x4
-
-    TASK_MAX_RUN_TIMES = 1440
-    TASKS_TO_RETRIEVE  = 5
-
-    # COM
-
-    CLSID_CTask = FFI::WIN32::GUID['148BD520-A2AB-11CE-B11F-00AA00530503']
-    IID_ITask = FFI::WIN32::GUID['148BD524-A2AB-11CE-B11F-00AA00530503']
-    IID_IPersistFile = FFI::WIN32::GUID['0000010b-0000-0000-C000-000000000046']
-
-    SCHED_S_TASK_READY                    = 0x00041300
-    SCHED_S_TASK_RUNNING                  = 0x00041301
-    SCHED_S_TASK_HAS_NOT_RUN              = 0x00041303
-    SCHED_S_TASK_NOT_SCHEDULED            = 0x00041305
-    # HRESULT error codes
-    # https://blogs.msdn.com/b/eldar/archive/2007/04/03/a-lot-of-hresult-codes.aspx
-    # in Ruby, an 0x8XXXXXXX style HRESULT can be resolved to 2s complement
-    # by using "0x8XXXXXXX".to_i(16) - - 0x100000000
-    SCHED_E_ACCOUNT_INFORMATION_NOT_SET   = -2147216625 # 0x8004130F
-    SCHED_E_NO_SECURITY_SERVICES          = -2147216622 # 0x80041312
-    # No mapping between account names and security IDs was done.
-    ERROR_NONE_MAPPED                     = -2147023564 # 0x80070534  WIN32 Error CODE 1332 (0x534)
-
-    # :startdoc:
-
-    # Shorthand constants
-    IDLE = Puppet::Util::Windows::Process::IDLE_PRIORITY_CLASS
-    NORMAL = Puppet::Util::Windows::Process::NORMAL_PRIORITY_CLASS
-    HIGH = Puppet::Util::Windows::Process::HIGH_PRIORITY_CLASS
-    REALTIME = Puppet::Util::Windows::Process::REALTIME_PRIORITY_CLASS
-    BELOW_NORMAL = Puppet::Util::Windows::Process::BELOW_NORMAL_PRIORITY_CLASS
-    ABOVE_NORMAL = Puppet::Util::Windows::Process::ABOVE_NORMAL_PRIORITY_CLASS
-
-    ONCE = TASK_TIME_TRIGGER_ONCE
-    DAILY = TASK_TIME_TRIGGER_DAILY
-    WEEKLY = TASK_TIME_TRIGGER_WEEKLY
-    MONTHLYDATE = TASK_TIME_TRIGGER_MONTHLYDATE
-    MONTHLYDOW = TASK_TIME_TRIGGER_MONTHLYDOW
-
-    ON_IDLE = TASK_EVENT_TRIGGER_ON_IDLE
-    AT_SYSTEMSTART = TASK_EVENT_TRIGGER_AT_SYSTEMSTART
-    AT_LOGON = TASK_EVENT_TRIGGER_AT_LOGON
-    FIRST_WEEK = TASK_FIRST_WEEK
-    SECOND_WEEK = TASK_SECOND_WEEK
-    THIRD_WEEK = TASK_THIRD_WEEK
-    FOURTH_WEEK = TASK_FOURTH_WEEK
-    LAST_WEEK = TASK_LAST_WEEK
-    SUNDAY = TASK_SUNDAY
-    MONDAY = TASK_MONDAY
-    TUESDAY = TASK_TUESDAY
-    WEDNESDAY = TASK_WEDNESDAY
-    THURSDAY = TASK_THURSDAY
-    FRIDAY = TASK_FRIDAY
-    SATURDAY = TASK_SATURDAY
-    JANUARY = TASK_JANUARY
-    FEBRUARY = TASK_FEBRUARY
-    MARCH = TASK_MARCH
-    APRIL = TASK_APRIL
-    MAY = TASK_MAY
-    JUNE = TASK_JUNE
-    JULY = TASK_JULY
-    AUGUST = TASK_AUGUST
-    SEPTEMBER = TASK_SEPTEMBER
-    OCTOBER = TASK_OCTOBER
-    NOVEMBER = TASK_NOVEMBER
-    DECEMBER = TASK_DECEMBER
-
-    INTERACTIVE = TASK_FLAG_INTERACTIVE
-    DELETE_WHEN_DONE = TASK_FLAG_DELETE_WHEN_DONE
-    DISABLED = TASK_FLAG_DISABLED
-    START_ONLY_IF_IDLE = TASK_FLAG_START_ONLY_IF_IDLE
-    KILL_ON_IDLE_END = TASK_FLAG_KILL_ON_IDLE_END
-    DONT_START_IF_ON_BATTERIES = TASK_FLAG_DONT_START_IF_ON_BATTERIES
-    KILL_IF_GOING_ON_BATTERIES = TASK_FLAG_KILL_IF_GOING_ON_BATTERIES
-    RUN_ONLY_IF_DOCKED = TASK_FLAG_RUN_ONLY_IF_DOCKED
-    HIDDEN = TASK_FLAG_HIDDEN
-    RUN_IF_CONNECTED_TO_INTERNET = TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET
-    RESTART_ON_IDLE_RESUME = TASK_FLAG_RESTART_ON_IDLE_RESUME
-    SYSTEM_REQUIRED = TASK_FLAG_SYSTEM_REQUIRED
-    RUN_ONLY_IF_LOGGED_ON = TASK_FLAG_RUN_ONLY_IF_LOGGED_ON
-
-    FLAG_HAS_END_DATE = TASK_TRIGGER_FLAG_HAS_END_DATE
-    FLAG_KILL_AT_DURATION_END = TASK_TRIGGER_FLAG_KILL_AT_DURATION_END
-    FLAG_DISABLED = TASK_TRIGGER_FLAG_DISABLED
-
-    MAX_RUN_TIMES = TASK_MAX_RUN_TIMES
-
-    # unfortunately MSTask.h does not specify the limits for any settings
-    # so these were determined with some experimentation
-    # if values too large are written, its suspected there may be internal
-    # limits may be exceeded, corrupting the job
-    # used for max application name and path values
-    MAX_PATH                = 260
-    # UNLEN from lmcons.h is 256
-    # https://technet.microsoft.com/it-it/library/bb726984(en-us).aspx specifies 104
-    MAX_ACCOUNT_LENGTH      = 256
-    # command line max length is limited to 8191, choose something high but still enough that we don't blow out CLI
-    MAX_PARAMETERS_LENGTH   = 4096
-    # in testing, this value could be set to a length of 99999, but saving / loading the task failed
-    MAX_COMMENT_LENGTH      = 8192
-
-    # Returns a new TaskScheduler object. If a work_item (and possibly the
-    # the trigger) are passed as arguments then a new work item is created and
-    # associated with that trigger, although you can still activate other tasks
-    # with the same handle.
-    #
-    # This is really just a bit of convenience. Passing arguments to the
-    # constructor is the same as calling TaskScheduler.new plus
-    # TaskScheduler#new_work_item.
-    #
-    def initialize(work_item=nil, trigger=nil)
-      @pITS   = nil
-      @pITask = nil
-
-      if ! self.class.com_initialized
-        Puppet::Util::Windows::COM.InitializeCom()
-        self.class.com_initialized = true
-      end
-
-      @pITS = COM::TaskScheduler.new
-      at_exit do
-        begin
-          @pITS.Release if @pITS && !@pITS.null?
-          @pITS = nil
-        rescue
-        end
-      end
-
-      if work_item
-        if trigger
-          raise TypeError unless trigger.is_a?(Hash)
-          new_work_item(work_item, trigger)
-        end
-      end
-    end
-
-    # Returns an array of scheduled task names.
-    #
-    def enum
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      array = []
-
-      @pITS.UseInstance(COM::EnumWorkItems, :Enum) do |pIEnum|
-        FFI::MemoryPointer.new(:pointer) do |names_array_ptr_ptr|
-          FFI::MemoryPointer.new(:win32_ulong) do |fetched_count_ptr|
-            # awkward usage, if number requested is available, returns S_OK (0), or if less were returned returns S_FALSE (1)
-            while (pIEnum.Next(TASKS_TO_RETRIEVE, names_array_ptr_ptr, fetched_count_ptr) >= Puppet::Util::Windows::COM::S_OK)
-              count = fetched_count_ptr.read_win32_ulong
-              break if count == 0
-
-              names_array_ptr_ptr.read_com_memory_pointer do |names_array_ptr|
-                # iterate over the array of pointers
-                name_ptr_ptr = FFI::Pointer.new(:pointer, names_array_ptr)
-                for i in 0 ... count
-                  name_ptr_ptr[i].read_com_memory_pointer do |name_ptr|
-                    array << name_ptr.read_arbitrary_wide_string_up_to(MAX_PATH)
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-
-      array
-    end
-
-    alias :tasks :enum
-
-    # Activate the specified task.
-    #
-    def activate(task)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise TypeError unless task.is_a?(String)
-
-      FFI::MemoryPointer.new(:pointer) do |ptr|
-        @pITS.Activate(wide_string(task), IID_ITask, ptr)
-
-        reset_current_task
-        @pITask = COM::Task.new(ptr.read_pointer)
-      end
-
-      @pITask
-    end
-
-    # Delete the specified task name.
-    #
-    def delete(task)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise TypeError unless task.is_a?(String)
-
-      @pITS.Delete(wide_string(task))
-
-      true
-    end
-
-    # Execute the current task.
-    #
-    def run
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      @pITask.Run
-    end
-
-    # Saves the current task. Tasks must be saved before they can be activated.
-    # The .job file itself is typically stored in the C:\WINDOWS\Tasks folder.
-    #
-    # If +file+ (an absolute path) is specified then the job is saved to that
-    # file instead. A '.job' extension is recommended but not enforced.
-    #
-    def save(file = nil)
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise Error.new(_('Account information must be set on the current task to save it properly.')) if !@account_information_set
-
-      reset = true
-
-      begin
-        @pITask.QueryInstance(COM::PersistFile) do |pIPersistFile|
-          wide_file = wide_string(file)
-          pIPersistFile.Save(wide_file, 1)
-          pIPersistFile.SaveCompleted(wide_file)
-        end
-      rescue
-        reset = false
-      ensure
-        reset_current_task if reset
-      end
-    end
-
-    # Terminate the current task.
-    #
-    def terminate
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      @pITask.Terminate
-    end
-
-    # Set the host on which the various TaskScheduler methods will execute.
-    #
-    def machine=(host)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise TypeError unless host.is_a?(String)
-
-      @pITS.SetTargetComputer(wide_string(host))
-
-      host
-    end
-
-    alias :host= :machine=
-
-    # Sets the +user+ and +password+ for the given task. If the user and
-    # password are set properly then true is returned.
-    #
-    # In some cases the job may be created, but the account information was
-    # bad. In this case the task is created but a warning is generated and
-    # false is returned.
-    #
-    # Note that if intending to use SYSTEM, specify an empty user and nil password
-    #
-    # Calling task.set_account_information('SYSTEM', nil) will generally not
-    # work, except for one special case where flags are also set like:
-    # task.flags = Win32::TaskScheduler::TASK_FLAG_RUN_ONLY_IF_LOGGED_ON
-    #
-    # This must be done prior to the 1st save() call for the task to be
-    # properly registered and visible through the MMC snap-in / schtasks.exe
-    #
-    def set_account_information(user, password)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      bool = false
-
-      begin
-        if (user.nil? || user=="") && (password.nil? || password=="")
-          @pITask.SetAccountInformation(wide_string(""), FFI::Pointer::NULL)
-        else
-          if user.length > MAX_ACCOUNT_LENGTH
-            raise Error.new(_("User has exceeded maximum allowed length %{max}") % { max: MAX_ACCOUNT_LENGTH })
-          end
-          user = wide_string(user)
-          password = wide_string(password)
-          @pITask.SetAccountInformation(user, password)
-        end
-
-        @account_information_set = true
-        bool = true
-      rescue Puppet::Util::Windows::Error => e
-        raise e unless e.code == SCHED_E_ACCOUNT_INFORMATION_NOT_SET
-
-        warn _('job created, but password was invalid')
-      end
-
-      bool
-    end
-
-    # Returns the user associated with the task or nil if no user has yet
-    # been associated with the task.
-    #
-    def account_information
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      # default under certain failures
-      user = nil
-
-      begin
-        FFI::MemoryPointer.new(:pointer) do |ptr|
-          @pITask.GetAccountInformation(ptr)
-          ptr.read_com_memory_pointer do |str_ptr|
-            user = str_ptr.read_arbitrary_wide_string_up_to(MAX_ACCOUNT_LENGTH) if ! str_ptr.null?
-          end
-        end
-      rescue Puppet::Util::Windows::Error => e
-        raise e unless e.code == SCHED_E_ACCOUNT_INFORMATION_NOT_SET ||
-                       e.code == SCHED_E_NO_SECURITY_SERVICES ||
-                       e.code == ERROR_NONE_MAPPED
-      end
-
-      user
-    end
-
-    # Returns the name of the application associated with the task.
-    #
-    def application_name
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      app = nil
-
-      FFI::MemoryPointer.new(:pointer) do |ptr|
-        @pITask.GetApplicationName(ptr)
-
-        ptr.read_com_memory_pointer do |str_ptr|
-          app = str_ptr.read_arbitrary_wide_string_up_to(MAX_PATH) if ! str_ptr.null?
-        end
-      end
-
-      app
-    end
-
-    # Sets the application name associated with the task.
-    #
-    def application_name=(app)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless app.is_a?(String)
-
-      # the application name is written to a .job file on disk, so is subject to path limitations
-      if app.length > MAX_PATH
-        raise Error.new(_("Application name has exceeded maximum allowed length %{max}") % { max: MAX_PATH })
-      end
-      @pITask.SetApplicationName(wide_string(app))
-
-      app
-    end
-
-    # Returns the command line parameters for the task.
-    #
-    def parameters
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      param = nil
-
-      FFI::MemoryPointer.new(:pointer) do |ptr|
-        @pITask.GetParameters(ptr)
-
-        ptr.read_com_memory_pointer do |str_ptr|
-          param = str_ptr.read_arbitrary_wide_string_up_to(MAX_PARAMETERS_LENGTH) if ! str_ptr.null?
-        end
-      end
-
-      param
-    end
-
-    # Sets the parameters for the task. These parameters are passed as command
-    # line arguments to the application the task will run. To clear the command
-    # line parameters set it to an empty string.
-    #
-    def parameters=(param)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless param.is_a?(String)
-
-      if param.length > MAX_PARAMETERS_LENGTH
-        raise Error.new(_("Parameters has exceeded maximum allowed length %{max}") % { max: MAX_PARAMETERS_LENGTH })
-      end
-
-      @pITask.SetParameters(wide_string(param))
-
-      param
-    end
-
-    # Returns the working directory for the task.
-    #
-    def working_directory
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      dir = nil
-
-      FFI::MemoryPointer.new(:pointer) do |ptr|
-        @pITask.GetWorkingDirectory(ptr)
-
-        ptr.read_com_memory_pointer do |str_ptr|
-          dir = str_ptr.read_arbitrary_wide_string_up_to(MAX_PATH) if ! str_ptr.null?
-        end
-      end
-
-      dir
-    end
-
-    # Sets the working directory for the task.
-    #
-    def working_directory=(dir)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless dir.is_a?(String)
-
-      if dir.length > MAX_PATH
-        raise Error.new(_("Working directory has exceeded maximum allowed length %{max}") % { max: MAX_PATH })
-      end
-
-      @pITask.SetWorkingDirectory(wide_string(dir))
-
-      dir
-    end
-
-    # Returns the task's priority level. Possible values are 'idle',
-    # 'normal', 'high', 'realtime', 'below_normal', 'above_normal',
-    # and 'unknown'.
-    #
-    def priority
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      priority_name = ''
-
-      FFI::MemoryPointer.new(:dword, 1) do |ptr|
-        @pITask.GetPriority(ptr)
-
-        pri = ptr.read_dword
-        if (pri & IDLE) != 0
-          priority_name = 'idle'
-        elsif (pri & NORMAL) != 0
-          priority_name = 'normal'
-        elsif (pri & HIGH) != 0
-          priority_name = 'high'
-        elsif (pri & REALTIME) != 0
-          priority_name = 'realtime'
-        elsif (pri & BELOW_NORMAL) != 0
-          priority_name = 'below_normal'
-        elsif (pri & ABOVE_NORMAL) != 0
-          priority_name = 'above_normal'
-        else
-          priority_name = 'unknown'
-        end
-      end
-
-      priority_name
-    end
-
-    # Sets the priority of the task. The +priority+ should be a numeric
-    # priority constant value.
-    #
-    def priority=(priority)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless priority.is_a?(Numeric)
-
-      @pITask.SetPriority(priority)
-
-      priority
-    end
-
-    # Creates a new work item (scheduled job) with the given +trigger+. The
-    # trigger variable is a hash of options that define when the scheduled
-    # job should run.
-    #
-    def new_work_item(task, trigger)
-      raise TypeError unless trigger.is_a?(Hash)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-
-      # I'm working around github issue #1 here.
-      enum.each{ |name|
-        if name.downcase == task.downcase + '.job'
-          raise Error.new(_("task '%{task}' already exists") % { task: task })
-        end
-      }
-
-      FFI::MemoryPointer.new(:pointer) do |ptr|
-        @pITS.NewWorkItem(wide_string(task), CLSID_CTask, IID_ITask, ptr)
-
-        reset_current_task
-        @pITask = COM::Task.new(ptr.read_pointer)
-
-        FFI::MemoryPointer.new(:word, 1) do |trigger_index_ptr|
-          # Without the 'enum.include?' check above the code segfaults here if the
-          # task already exists. This should probably be handled properly instead
-          # of simply avoiding the issue.
-
-          @pITask.UseInstance(COM::TaskTrigger, :CreateTrigger, trigger_index_ptr) do |pITaskTrigger|
-            populate_trigger(pITaskTrigger, trigger)
-          end
-        end
-      end
-
-      # preload task with the SYSTEM account
-      # empty string '' means 'SYSTEM' per MSDN, so default it
-      # given an account is necessary for creation of a task
-      # note that a user may set SYSTEM explicitly, but that has problems
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa381276(v=vs.85).aspx
-      set_account_information('', nil)
-
-      @pITask
-    end
-
-    alias :new_task :new_work_item
-
-    # Returns the number of triggers associated with the active task.
-    #
-    def trigger_count
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      count = 0
-
-      FFI::MemoryPointer.new(:word, 1) do |ptr|
-        @pITask.GetTriggerCount(ptr)
-        count = ptr.read_word
-      end
-
-      count
-    end
-
-    # Deletes the trigger at the specified index.
-    #
-    def delete_trigger(index)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      @pITask.DeleteTrigger(index)
-      index
-    end
-
-    # Returns a hash that describes the trigger at the given index for the
-    # current task.
-    #
-    def trigger(index)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      trigger = {}
-
-      @pITask.UseInstance(COM::TaskTrigger, :GetTrigger, index) do |pITaskTrigger|
-        FFI::MemoryPointer.new(COM::TASK_TRIGGER.size) do |task_trigger_ptr|
-          pITaskTrigger.GetTrigger(task_trigger_ptr)
-          trigger = populate_hash_from_trigger(COM::TASK_TRIGGER.new(task_trigger_ptr))
-        end
-      end
-
-      trigger
-    end
-
-    # Sets the trigger for the currently active task.
-    #
-    def trigger=(trigger)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless trigger.is_a?(Hash)
-
-      FFI::MemoryPointer.new(:word, 1) do |trigger_index_ptr|
-        # Without the 'enum.include?' check above the code segfaults here if the
-        # task already exists. This should probably be handled properly instead
-        # of simply avoiding the issue.
-
-        @pITask.UseInstance(COM::TaskTrigger, :CreateTrigger, trigger_index_ptr) do |pITaskTrigger|
-          populate_trigger(pITaskTrigger, trigger)
-        end
-      end
-
-      trigger
-    end
-
-    # Adds a trigger at the specified index.
-    #
-    def add_trigger(index, trigger)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless trigger.is_a?(Hash)
-
-      @pITask.UseInstance(COM::TaskTrigger, :GetTrigger, index) do |pITaskTrigger|
-        populate_trigger(pITaskTrigger, trigger)
-      end
-    end
-
-    # Returns the flags (integer) that modify the behavior of the work item. You
-    # must OR the return value to determine the flags yourself.
-    #
-    def flags
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      flags = 0
-
-      FFI::MemoryPointer.new(:dword, 1) do |ptr|
-        @pITask.GetFlags(ptr)
-        flags = ptr.read_dword
-      end
-
-      flags
-    end
-
-    # Sets an OR'd value of flags that modify the behavior of the work item.
-    #
-    def flags=(flags)
-      raise Error.new(_('No current task scheduler. ITaskScheduler is NULL.')) if @pITS.nil?
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      @pITask.SetFlags(flags)
-      flags
-    end
-
-    # Returns the status of the currently active task. Possible values are
-    # 'ready', 'running', 'not scheduled' or 'unknown'.
-    #
-    def status
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      st = nil
-
-      FFI::MemoryPointer.new(:hresult, 1) do |ptr|
-        @pITask.GetStatus(ptr)
-        st = ptr.read_hresult
-      end
-
-      case st
-        when SCHED_S_TASK_READY
-           status = 'ready'
-        when SCHED_S_TASK_RUNNING
-           status = 'running'
-        when SCHED_S_TASK_NOT_SCHEDULED
-           status = 'not scheduled'
-        else
-           status = 'unknown'
-      end
-
-      status
-    end
-
-    # Returns the exit code from the last scheduled run.
-    #
-    def exit_code
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      status = 0
-
-      begin
-        FFI::MemoryPointer.new(:dword, 1) do |ptr|
-          @pITask.GetExitCode(ptr)
-          status = ptr.read_dword
-        end
-      rescue Puppet::Util::Windows::Error => e
-        raise e unless e.code == SCHED_S_TASK_HAS_NOT_RUN
-      end
-
-      status
-    end
-
-    # Returns the comment associated with the task, if any.
-    #
-    def comment
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      comment = nil
-
-      FFI::MemoryPointer.new(:pointer) do |ptr|
-        @pITask.GetComment(ptr)
-
-        ptr.read_com_memory_pointer do |str_ptr|
-          comment = str_ptr.read_arbitrary_wide_string_up_to(MAX_COMMENT_LENGTH) if ! str_ptr.null?
-        end
-      end
-
-      comment
-    end
-
-    # Sets the comment for the task.
-    #
-    def comment=(comment)
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless comment.is_a?(String)
-
-      if comment.length > MAX_COMMENT_LENGTH
-        raise Error.new(_("Comment has exceeded maximum allowed length %{max}") % { max: MAX_COMMENT_LENGTH })
-      end
-
-      @pITask.SetComment(wide_string(comment))
-      comment
-    end
-
-    # Returns the name of the user who created the task.
-    #
-    def creator
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      creator = nil
-
-      FFI::MemoryPointer.new(:pointer) do |ptr|
-        @pITask.GetCreator(ptr)
-
-        ptr.read_com_memory_pointer do |str_ptr|
-          creator = str_ptr.read_arbitrary_wide_string_up_to(MAX_ACCOUNT_LENGTH) if ! str_ptr.null?
-        end
-      end
-
-      creator
-    end
-
-    # Sets the creator for the task.
-    #
-    def creator=(creator)
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless creator.is_a?(String)
-
-      if creator.length > MAX_ACCOUNT_LENGTH
-        raise Error.new(_("Creator has exceeded maximum allowed length %{max}") % { max: MAX_ACCOUNT_LENGTH })
-      end
-
-
-      @pITask.SetCreator(wide_string(creator))
-      creator
-    end
-
-    # Returns a Time object that indicates the next time the task will run.
-    #
-    def next_run_time
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      time = nil
-
-      FFI::MemoryPointer.new(WIN32::SYSTEMTIME.size) do |ptr|
-        @pITask.GetNextRunTime(ptr)
-        time = WIN32::SYSTEMTIME.new(ptr).to_local_time
-      end
-
-      time
-    end
-
-    # Returns a Time object indicating the most recent time the task ran or
-    # nil if the task has never run.
-    #
-    def most_recent_run_time
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      time = nil
-
-      begin
-        FFI::MemoryPointer.new(WIN32::SYSTEMTIME.size) do |ptr|
-          @pITask.GetMostRecentRunTime(ptr)
-          time = WIN32::SYSTEMTIME.new(ptr).to_local_time
-        end
-      rescue Puppet::Util::Windows::Error => e
-        raise e unless e.code == SCHED_S_TASK_HAS_NOT_RUN
-      end
-
-      time
-    end
-
-    # Returns the maximum length of time, in milliseconds, that the task
-    # will run before terminating.
-    #
-    def max_run_time
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-
-      max_run_time = nil
-
-      FFI::MemoryPointer.new(:dword, 1) do |ptr|
-        @pITask.GetMaxRunTime(ptr)
-        max_run_time = ptr.read_dword
-      end
-
-      max_run_time
-    end
-
-    # Sets the maximum length of time, in milliseconds, that the task can run
-    # before terminating. Returns the value you specified if successful.
-    #
-    def max_run_time=(max_run_time)
-      raise Error.new(_('No currently active task. ITask is NULL.')) if @pITask.nil?
-      raise TypeError unless max_run_time.is_a?(Numeric)
-
-      @pITask.SetMaxRunTime(max_run_time)
-      max_run_time
-    end
-
-    # Returns whether or not the scheduled task exists.
-    def exists?(job_name)
-      # task name comparison is case insensitive
-      tasks.any? { |name| name.casecmp(job_name + '.job') == 0 }
-    end
-
-    private
-
-    # :stopdoc:
-
-    # Used for the new_work_item method
-    ValidTriggerKeys = [
-      'end_day',
-      'end_month',
-      'end_year',
-      'flags',
-      'minutes_duration',
-      'minutes_interval',
-      'random_minutes_interval',
-      'start_day',
-      'start_hour',
-      'start_minute',
-      'start_month',
-      'start_year',
-      'trigger_type',
-      'type'
-    ]
-
-    ValidTypeKeys = [
-       'days_interval',
-       'weeks_interval',
-       'days_of_week',
-       'months',
-       'days',
-       'weeks'
-    ]
-
-    # Private method that validates keys, and converts all keys to lowercase
-    # strings.
-    #
-    def transform_and_validate(hash)
-      new_hash = {}
-
-      hash.each{ |key, value|
-        key = key.to_s.downcase
-        if key == 'type'
-          new_type_hash = {}
-          raise ArgumentError unless value.is_a?(Hash)
-          value.each{ |subkey, subvalue|
-            subkey = subkey.to_s.downcase
-            if ValidTypeKeys.include?(subkey)
-              new_type_hash[subkey] = subvalue
-            else
-              raise ArgumentError, _("Invalid type key '%{key}'") % { key: subkey }
-            end
-          }
-          new_hash[key] = new_type_hash
-        else
-          if ValidTriggerKeys.include?(key)
-            new_hash[key] = value
-          else
-            raise ArgumentError, _("Invalid key '%{key}'") % { key: key }
-          end
-        end
-      }
-
-      new_hash
-    end
-
-    def reset_current_task
-      # Ensure that COM reference is decremented properly
-      @pITask.Release if @pITask && ! @pITask.null?
-      @pITask = nil
-      @account_information_set = false
-    end
-
-    def populate_trigger(task_trigger, trigger)
-      raise TypeError unless task_trigger.is_a?(COM::TaskTrigger)
-      trigger = transform_and_validate(trigger)
-
-      FFI::MemoryPointer.new(COM::TASK_TRIGGER.size) do |trigger_ptr|
-        FFI::MemoryPointer.new(COM::TRIGGER_TYPE_UNION.size) do |trigger_type_union_ptr|
-          trigger_type_union = COM::TRIGGER_TYPE_UNION.new(trigger_type_union_ptr)
-
-          tmp = trigger['type'].is_a?(Hash) ? trigger['type'] : nil
-          case trigger['trigger_type']
-            when :TASK_TIME_TRIGGER_DAILY
-              if tmp && tmp['days_interval']
-                trigger_type_union[:Daily][:DaysInterval] = tmp['days_interval']
-              end
-            when :TASK_TIME_TRIGGER_WEEKLY
-              if tmp && tmp['weeks_interval'] && tmp['days_of_week']
-                trigger_type_union[:Weekly][:WeeksInterval] = tmp['weeks_interval']
-                trigger_type_union[:Weekly][:rgfDaysOfTheWeek] = tmp['days_of_week']
-              end
-            when :TASK_TIME_TRIGGER_MONTHLYDATE
-              if tmp && tmp['months'] && tmp['days']
-                trigger_type_union[:MonthlyDate][:rgfDays] = tmp['days']
-                trigger_type_union[:MonthlyDate][:rgfMonths] = tmp['months']
-              end
-            when :TASK_TIME_TRIGGER_MONTHLYDOW
-              if tmp && tmp['weeks'] && tmp['days_of_week'] && tmp['months']
-                trigger_type_union[:MonthlyDOW][:wWhichWeek] = tmp['weeks']
-                trigger_type_union[:MonthlyDOW][:rgfDaysOfTheWeek] = tmp['days_of_week']
-                trigger_type_union[:MonthlyDOW][:rgfMonths] = tmp['months']
-              end
-            when :TASK_TIME_TRIGGER_ONCE
-              # Do nothing. The Type member of the TASK_TRIGGER struct is ignored.
-            else
-              raise Error.new(_("Unknown trigger type %{type}") % { type: trigger['trigger_type'] })
-          end
-
-          trigger_struct = COM::TASK_TRIGGER.new(trigger_ptr)
-          trigger_struct[:cbTriggerSize] = COM::TASK_TRIGGER.size
-          now = Time.now
-          trigger_struct[:wBeginYear] = trigger['start_year'] || now.year
-          trigger_struct[:wBeginMonth] = trigger['start_month'] || now.month
-          trigger_struct[:wBeginDay] = trigger['start_day'] || now.day
-          trigger_struct[:wEndYear] = trigger['end_year'] || 0
-          trigger_struct[:wEndMonth] = trigger['end_month'] || 0
-          trigger_struct[:wEndDay] = trigger['end_day'] || 0
-          trigger_struct[:wStartHour] = trigger['start_hour'] || 0
-          trigger_struct[:wStartMinute] = trigger['start_minute'] || 0
-          trigger_struct[:MinutesDuration] = trigger['minutes_duration'] || 0
-          trigger_struct[:MinutesInterval] = trigger['minutes_interval'] || 0
-          trigger_struct[:rgFlags] = trigger['flags'] || 0
-          trigger_struct[:TriggerType] = trigger['trigger_type'] || :TASK_TIME_TRIGGER_ONCE
-          trigger_struct[:Type] = trigger_type_union
-          trigger_struct[:wRandomMinutesInterval] = trigger['random_minutes_interval'] || 0
-
-          task_trigger.SetTrigger(trigger_struct)
-        end
-      end
-    end
-
-    def populate_hash_from_trigger(task_trigger)
-      raise TypeError unless task_trigger.is_a?(COM::TASK_TRIGGER)
-
-      trigger = {
-        'start_year' => task_trigger[:wBeginYear],
-        'start_month' => task_trigger[:wBeginMonth],
-        'start_day' => task_trigger[:wBeginDay],
-        'end_year' => task_trigger[:wEndYear],
-        'end_month' => task_trigger[:wEndMonth],
-        'end_day' => task_trigger[:wEndDay],
-        'start_hour' => task_trigger[:wStartHour],
-        'start_minute' => task_trigger[:wStartMinute],
-        'minutes_duration' => task_trigger[:MinutesDuration],
-        'minutes_interval' => task_trigger[:MinutesInterval],
-        'flags' => task_trigger[:rgFlags],
-        'trigger_type' => task_trigger[:TriggerType],
-        'random_minutes_interval' => task_trigger[:wRandomMinutesInterval]
-      }
-
-      case task_trigger[:TriggerType]
-        when :TASK_TIME_TRIGGER_DAILY
-          trigger['type'] = { 'days_interval' => task_trigger[:Type][:Daily][:DaysInterval] }
-        when :TASK_TIME_TRIGGER_WEEKLY
-          trigger['type'] = {
-            'weeks_interval' => task_trigger[:Type][:Weekly][:WeeksInterval],
-            'days_of_week' => task_trigger[:Type][:Weekly][:rgfDaysOfTheWeek]
-          }
-        when :TASK_TIME_TRIGGER_MONTHLYDATE
-          trigger['type'] = {
-            'days' => task_trigger[:Type][:MonthlyDate][:rgfDays],
-            'months' => task_trigger[:Type][:MonthlyDate][:rgfMonths]
-          }
-        when :TASK_TIME_TRIGGER_MONTHLYDOW
-          trigger['type'] = {
-            'weeks' => task_trigger[:Type][:MonthlyDOW][:wWhichWeek],
-            'days_of_week' => task_trigger[:Type][:MonthlyDOW][:rgfDaysOfTheWeek],
-            'months' => task_trigger[:Type][:MonthlyDOW][:rgfMonths]
-          }
-        when :TASK_TIME_TRIGGER_ONCE
-          trigger['type'] = { 'once' => nil }
-        else
-          raise Error.new(_("Unknown trigger type %{type}") % { type: task_trigger[:TriggerType] })
-      end
-
-      trigger
-    end
-
-    module COM
-      extend FFI::Library
-
-      com = Puppet::Util::Windows::COM
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa381811(v=vs.85).aspx
-      ITaskScheduler = com::Interface[com::IUnknown,
-        FFI::WIN32::GUID['148BD527-A2AB-11CE-B11F-00AA00530503'],
-
-        SetTargetComputer: [[:lpcwstr], :hresult],
-        # LPWSTR *
-        GetTargetComputer: [[:pointer], :hresult],
-        # IEnumWorkItems **
-        Enum: [[:pointer], :hresult],
-        # LPCWSTR, REFIID, IUnknown **
-        Activate: [[:lpcwstr, :pointer, :pointer], :hresult],
-        Delete: [[:lpcwstr], :hresult],
-        # LPCWSTR, REFCLSID, REFIID, IUnknown **
-        NewWorkItem: [[:lpcwstr, :pointer, :pointer, :pointer], :hresult],
-        # LPCWSTR, IScheduledWorkItem *
-        AddWorkItem: [[:lpcwstr, :pointer], :hresult],
-        # LPCWSTR, REFIID
-        IsOfType: [[:lpcwstr, :pointer], :hresult]
-      ]
-
-      TaskScheduler = com::Factory[ITaskScheduler,
-        FFI::WIN32::GUID['148BD52A-A2AB-11CE-B11F-00AA00530503']]
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa380706(v=vs.85).aspx
-      IEnumWorkItems = com::Interface[com::IUnknown,
-        FFI::WIN32::GUID['148BD528-A2AB-11CE-B11F-00AA00530503'],
-
-        # ULONG, LPWSTR **, ULONG *
-        Next: [[:win32_ulong, :pointer, :pointer], :hresult],
-        Skip: [[:win32_ulong], :hresult],
-        Reset: [[], :hresult],
-        # IEnumWorkItems ** ppEnumWorkItems
-        Clone: [[:pointer], :hresult]
-      ]
-
-      EnumWorkItems = com::Instance[IEnumWorkItems]
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa381216(v=vs.85).aspx
-      IScheduledWorkItem = com::Interface[com::IUnknown,
-        FFI::WIN32::GUID['a6b952f0-a4b1-11d0-997d-00aa006887ec'],
-
-        # WORD *, ITaskTrigger **
-        CreateTrigger: [[:pointer, :pointer], :hresult],
-        DeleteTrigger: [[:word], :hresult],
-        # WORD *
-        GetTriggerCount: [[:pointer], :hresult],
-        # WORD, ITaskTrigger **
-        GetTrigger: [[:word, :pointer], :hresult],
-        # WORD, LPWSTR *
-        GetTriggerString: [[:word, :pointer], :hresult],
-        # LPSYSTEMTIME, LPSYSTEMTIME, WORD *, LPSYSTEMTIME *
-        GetRunTimes: [[:pointer, :pointer, :pointer, :pointer], :hresult],
-        # SYSTEMTIME *
-        GetNextRunTime: [[:pointer], :hresult],
-        SetIdleWait: [[:word, :word], :hresult],
-        # WORD *, WORD *
-        GetIdleWait: [[:pointer, :pointer], :hresult],
-        Run: [[], :hresult],
-        Terminate: [[], :hresult],
-        EditWorkItem: [[:hwnd, :dword], :hresult],
-        # SYSTEMTIME *
-        GetMostRecentRunTime: [[:pointer], :hresult],
-        # HRESULT *
-        GetStatus: [[:pointer], :hresult],
-        GetExitCode: [[:pdword], :hresult],
-        SetComment: [[:lpcwstr], :hresult],
-        # LPWSTR *
-        GetComment: [[:pointer], :hresult],
-        SetCreator: [[:lpcwstr], :hresult],
-        # LPWSTR *
-        GetCreator: [[:pointer], :hresult],
-        # WORD, BYTE[]
-        SetWorkItemData: [[:word, :buffer_in], :hresult],
-        # WORD *, BYTE **
-        GetWorkItemData: [[:pointer, :pointer], :hresult],
-        SetErrorRetryCount: [[:word], :hresult],
-        # WORD *
-        GetErrorRetryCount: [[:pointer], :hresult],
-        SetErrorRetryInterval: [[:word], :hresult],
-        # WORD *
-        GetErrorRetryInterval: [[:pointer], :hresult],
-        SetFlags: [[:dword], :hresult],
-        # WORD *
-        GetFlags: [[:pointer], :hresult],
-        SetAccountInformation: [[:lpcwstr, :lpcwstr], :hresult],
-        # LPWSTR *
-        GetAccountInformation: [[:pointer], :hresult]
-      ]
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa381311(v=vs.85).aspx
-      ITask = com::Interface[IScheduledWorkItem,
-        FFI::WIN32::GUID['148BD524-A2AB-11CE-B11F-00AA00530503'],
-
-        SetApplicationName: [[:lpcwstr], :hresult],
-        # LPWSTR *
-        GetApplicationName: [[:pointer], :hresult],
-        SetParameters: [[:lpcwstr], :hresult],
-        # LPWSTR *
-        GetParameters: [[:pointer], :hresult],
-        SetWorkingDirectory: [[:lpcwstr], :hresult],
-        # LPWSTR *
-        GetWorkingDirectory: [[:pointer], :hresult],
-        SetPriority: [[:dword], :hresult],
-        # DWORD *
-        GetPriority: [[:pointer], :hresult],
-        SetTaskFlags: [[:dword], :hresult],
-        # DWORD *
-        GetTaskFlags: [[:pointer], :hresult],
-        SetMaxRunTime: [[:dword], :hresult],
-        # DWORD *
-        GetMaxRunTime: [[:pointer], :hresult]
-      ]
-
-      Task = com::Instance[ITask]
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/ms688695(v=vs.85).aspx
-      IPersist = com::Interface[com::IUnknown,
-        FFI::WIN32::GUID['0000010c-0000-0000-c000-000000000046'],
-        # CLSID *
-        GetClassID: [[:pointer], :hresult]
-      ]
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/ms687223(v=vs.85).aspx
-      IPersistFile = com::Interface[IPersist,
-        FFI::WIN32::GUID['0000010b-0000-0000-C000-000000000046'],
-
-        IsDirty: [[], :hresult],
-        Load: [[:lpcolestr, :dword], :hresult],
-        Save: [[:lpcolestr, :win32_bool], :hresult],
-        SaveCompleted: [[:lpcolestr], :hresult],
-        # LPOLESTR *
-        GetCurFile: [[:pointer], :hresult]
-      ]
-
-      PersistFile = com::Instance[IPersistFile]
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa381864(v=vs.85).aspx
-      ITaskTrigger = com::Interface[com::IUnknown,
-        FFI::WIN32::GUID['148BD52B-A2AB-11CE-B11F-00AA00530503'],
-
-        SetTrigger: [[:pointer], :hresult],
-        GetTrigger: [[:pointer], :hresult],
-        GetTriggerString: [[:pointer], :hresult]
-      ]
-
-      TaskTrigger = com::Instance[ITaskTrigger]
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383620(v=vs.85).aspx
-      # The TASK_TRIGGER_TYPE field of the TASK_TRIGGER structure determines
-      # which member of the TRIGGER_TYPE_UNION field to use.
-      TASK_TRIGGER_TYPE = enum(
-        :TASK_TIME_TRIGGER_ONCE, 0,             # Ignore the Type field
-        :TASK_TIME_TRIGGER_DAILY, 1,
-        :TASK_TIME_TRIGGER_WEEKLY, 2,
-        :TASK_TIME_TRIGGER_MONTHLYDATE, 3,
-        :TASK_TIME_TRIGGER_MONTHLYDOW,  4,
-        :TASK_EVENT_TRIGGER_ON_IDLE, 5,         # Ignore the Type field
-        :TASK_EVENT_TRIGGER_AT_SYSTEMSTART, 6,  # Ignore the Type field
-        :TASK_EVENT_TRIGGER_AT_LOGON, 7         # Ignore the Type field
-      )
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa446857(v=vs.85).aspx
-      class DAILY < FFI::Struct
-        layout :DaysInterval, :word
-      end
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa384014(v=vs.85).aspx
-      class WEEKLY < FFI::Struct
-        layout :WeeksInterval, :word,
-               :rgfDaysOfTheWeek, :word
-      end
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa381918(v=vs.85).aspx
-      class MONTHLYDATE < FFI::Struct
-        layout :rgfDays, :dword,
-               :rgfMonths, :word
-      end
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa381918(v=vs.85).aspx
-      class MONTHLYDOW < FFI::Struct
-        layout :wWhichWeek, :word,
-               :rgfDaysOfTheWeek, :word,
-               :rgfMonths, :word
-      end
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa384002(v=vs.85).aspx
-      class TRIGGER_TYPE_UNION < FFI::Union
-        layout :Daily, DAILY,
-               :Weekly, WEEKLY,
-               :MonthlyDate, MONTHLYDATE,
-               :MonthlyDOW, MONTHLYDOW
-      end
-
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383618(v=vs.85).aspx
-      class TASK_TRIGGER < FFI::Struct
-        layout :cbTriggerSize, :word,            # Structure size.
-               :Reserved1, :word,                # Reserved. Must be zero.
-               :wBeginYear, :word,               # Trigger beginning date year.
-               :wBeginMonth, :word,              # Trigger beginning date month.
-               :wBeginDay, :word,                # Trigger beginning date day.
-               :wEndYear, :word,                 # Optional trigger ending date year.
-               :wEndMonth, :word,                # Optional trigger ending date month.
-               :wEndDay, :word,                  # Optional trigger ending date day.
-               :wStartHour, :word,               # Run bracket start time hour.
-               :wStartMinute, :word,             # Run bracket start time minute.
-               :MinutesDuration, :dword,         # Duration of run bracket.
-               :MinutesInterval, :dword,         # Run bracket repetition interval.
-               :rgFlags, :dword,                 # Trigger flags.
-               :TriggerType, TASK_TRIGGER_TYPE,  # Trigger type.
-               :Type, TRIGGER_TYPE_UNION,        # Trigger data.
-               :Reserved2, :word,                # Reserved. Must be zero.
-               :wRandomMinutesInterval, :word    # Maximum number of random minutes after start time
-      end
-    end
-  end
-end