Server IP : 66.29.132.122 / Your IP : 18.191.60.249 Web Server : LiteSpeed System : Linux business142.web-hosting.com 4.18.0-553.lve.el8.x86_64 #1 SMP Mon May 27 15:27:34 UTC 2024 x86_64 User : admazpex ( 531) PHP Version : 7.2.34 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /proc/self/root/proc/self/root/proc/thread-self/root/proc/thread-self/root/opt/puppetlabs/puppet/vendor_modules/scheduled_task/spec/ |
Upload File : |
# frozen_string_literal: true # DO NOT EDIT, ALTER, OR DELETE THIS FILE # This file is copied from core puppet and frozen # It is used in spec tests to ensure compatibility # between this module and the old built-in type. # Frozen from: https://github.com/puppetlabs/puppet/blob/5.5.3/lib/puppet/util/windows/taskscheduler.rb require 'puppet/util/windows' # disabling some false positives on the FFI definitions # rubocop:disable Naming/ClassAndModuleCamelCase,Naming/ConstantName,Lint/Void # The TaskScheduler class encapsulates taskscheduler settings and behavior class Win32::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 # rubocop:disable Style/NumericLiterals 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) # rubocop:enable Style/NumericLiterals # :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 unless self.class.com_initialized Puppet::Util::Windows::COM.InitializeCom() self.class.com_initialized = true end @pits = COM::TaskScheduler.new at_exit do @pits.Release if @pits && !@pits.null? @pits = nil rescue # rubocop:disable Lint/SuppressedException end raise TypeError if work_item && trigger && !trigger.is_a?(Hash) new_work_item(work_item, trigger) if work_item && trigger end # Returns an array of scheduled task names. # def enum raise Error, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? array = [] @pits.UseInstance(COM::EnumWorkItems, :Enum) do |pi_enum| 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 pi_enum.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) (0...count).each do |i| 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, _('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, _('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, _('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, _('No currently active task. ITask is NULL.') if @pitask.nil? raise Error, _('Account information must be set on the current task to save it properly.') unless @account_information_set reset = true begin @pitask.QueryInstance(COM::PersistFile) do |pi_persist_file| wide_file = wide_string(file) pi_persist_file.Save(wide_file, 1) pi_persist_file.SaveCompleted(wide_file) end rescue reset = false ensure reset_current_task if reset end end # Terminate the current task. # def terminate raise Error, _('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, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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) unless 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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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) unless str_ptr.null? end end app end # Sets the application name associated with the task. # def application_name=(app) raise Error, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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) unless 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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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) unless str_ptr.null? end end dir end # Sets the working directory for the task. # def working_directory=(dir) raise Error, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('No currently active task. ITask is NULL.') if @pitask.nil? raise TypeError unless dir.is_a?(String) if dir.length > MAX_PATH raise Error, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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 priority_name = if (pri & IDLE) != 0 'idle' elsif (pri & NORMAL) != 0 'normal' elsif (pri & HIGH) != 0 'high' elsif (pri & REALTIME) != 0 'realtime' elsif (pri & BELOW_NORMAL) != 0 'below_normal' elsif (pri & ABOVE_NORMAL) != 0 'above_normal' else '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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? # I'm working around github issue #1 here. enum.each do |name| if name.downcase == task.downcase + '.job' raise Error, _("task '%{task}' already exists") % { task: task } end 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 |pitask_trigger| populate_trigger(pitask_trigger, 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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('No currently active task. ITask is NULL.') if @pitask.nil? trigger = {} @pitask.UseInstance(COM::TaskTrigger, :GetTrigger, index) do |pitask_trigger| FFI::MemoryPointer.new(COM::TASK_TRIGGER.size) do |task_trigger_ptr| pitask_trigger.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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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 |pitask_trigger| populate_trigger(pitask_trigger, trigger) end end trigger end # Adds a trigger at the specified index. # def add_trigger(index, trigger) raise Error, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('No currently active task. ITask is NULL.') if @pitask.nil? raise TypeError unless trigger.is_a?(Hash) @pitask.UseInstance(COM::TaskTrigger, :GetTrigger, index) do |pitask_trigger| populate_trigger(pitask_trigger, 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, _('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, _('No current task scheduler. ITaskScheduler is NULL.') if @pits.nil? raise Error, _('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, _('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 status = case st when SCHED_S_TASK_READY 'ready' when SCHED_S_TASK_RUNNING 'running' when SCHED_S_TASK_NOT_SCHEDULED 'not scheduled' else 'unknown' end status end # Returns the exit code from the last scheduled run. # def exit_code raise Error, _('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, _('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) unless str_ptr.null? end end comment end # Sets the comment for the task. # def comment=(comment) raise Error, _('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, _('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, _('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) unless str_ptr.null? end end creator end # Sets the creator for the task. # def creator=(creator) raise Error, _('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, _('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, _('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, _('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, _('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, _('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', ].freeze ValidTypeKeys = [ 'days_interval', 'weeks_interval', 'days_of_week', 'months', 'days', 'weeks', ].freeze # Private method that validates keys, and converts all keys to lowercase # strings. # def transform_and_validate(hash) new_hash = {} hash.each do |key, value| key = key.to_s.downcase if key == 'type' new_type_hash = {} raise ArgumentError unless value.is_a?(Hash) value.each do |subkey, subvalue| subkey = subkey.to_s.downcase raise ArgumentError, _("Invalid type key '%{key}'") % { key: subkey } unless ValidTypeKeys.include?(subkey) new_type_hash[subkey] = subvalue end new_hash[key] = new_type_hash elsif 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. nil else raise Error, _('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, _('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