public Collection <ScheduledJobTrigger> GetJobTriggers(string taskId) { if (!string.IsNullOrEmpty(taskId)) { ITaskDefinition variable = this.FindTask(taskId); Collection <ScheduledJobTrigger> scheduledJobTriggers = new Collection <ScheduledJobTrigger>(); ITriggerCollection triggers = variable.Triggers; if (triggers != null) { foreach (ITrigger trigger in triggers) { ScheduledJobTrigger scheduledJobTrigger = this.CreateJobTrigger(trigger); if (scheduledJobTrigger != null) { scheduledJobTriggers.Add(scheduledJobTrigger); } else { object[] id = new object[2]; id[0] = taskId; id[1] = trigger.Id; string str = StringUtil.Format(ScheduledJobErrorStrings.UnknownTriggerType, id); throw new ScheduledJobException(str); } } } return(scheduledJobTriggers); } else { throw new PSArgumentException("taskId"); } }
public void CreateTask(ScheduledJobDefinition definition) { if (definition != null) { ITaskDefinition variable = this._taskScheduler.NewTask(0); this.AddTaskOptions(variable, definition.Options); foreach (ScheduledJobTrigger jobTrigger in definition.JobTriggers) { this.AddTaskTrigger(variable, jobTrigger); } this.AddTaskAction(variable, definition); string str = "D:P(A;;GA;;;SY)(A;;GA;;;BA)"; SecurityIdentifier user = WindowsIdentity.GetCurrent().User; CommonSecurityDescriptor commonSecurityDescriptor = new CommonSecurityDescriptor(false, false, str); commonSecurityDescriptor.DiscretionaryAcl.AddAccess(AccessControlType.Allow, user, 0x10000000, InheritanceFlags.None, PropagationFlags.None); string sddlForm = commonSecurityDescriptor.GetSddlForm(AccessControlSections.All); if (definition.Credential != null) { this._iRootFolder.RegisterTaskDefinition(definition.Name, variable, 2, definition.Credential.UserName, this.GetCredentialPassword(definition.Credential), _TASK_LOGON_TYPE.TASK_LOGON_PASSWORD, sddlForm); return; } else { this._iRootFolder.RegisterTaskDefinition(definition.Name, variable, 2, null, null, _TASK_LOGON_TYPE.TASK_LOGON_S4U, sddlForm); return; } } else { throw new PSArgumentNullException("definition"); } }
/// <summary> /// Retrieves job triggers from WTS with provided task Id. /// </summary> /// <param name="taskId">Task Id</param> /// <exception cref="ScheduledJobException">Task not found.</exception> /// <returns>ScheduledJobTriggers</returns> public Collection <ScheduledJobTrigger> GetJobTriggers( string taskId) { if (string.IsNullOrEmpty(taskId)) { throw new PSArgumentException("taskId"); } ITaskDefinition iTaskDefinition = FindTask(taskId); Collection <ScheduledJobTrigger> jobTriggers = new Collection <ScheduledJobTrigger>(); ITriggerCollection iTriggerCollection = iTaskDefinition.Triggers; if (iTriggerCollection != null) { foreach (ITrigger iTrigger in iTriggerCollection) { ScheduledJobTrigger jobTrigger = CreateJobTrigger(iTrigger); if (jobTrigger == null) { string msg = StringUtil.Format(ScheduledJobErrorStrings.UnknownTriggerType, taskId, iTrigger.Id); throw new ScheduledJobException(msg); } jobTriggers.Add(jobTrigger); } } return(jobTriggers); }
static void Main() { String instDir = Environment.GetEnvironmentVariable("PROGRAMFILES") + "\\win7bel\\"; try { TaskSchedulerClass ts = new TaskSchedulerClass(); ts.Connect(null, null, null, null); ITaskFolder root = ts.GetFolder("\\"); ITaskDefinition task = ts.NewTask(0); task.Settings.RunOnlyIfNetworkAvailable = true; task.Settings.StartWhenAvailable = true; IDailyTrigger trigger = (IDailyTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY); trigger.StartBoundary = "2011-01-01T15:00:00"; IExecAction exec = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC); exec.Id = "win7bel-updater"; exec.Path = instDir + "win7bel-updater.exe"; IRegisteredTask regTask = root.RegisterTaskDefinition("win7bel-updater", task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, ""); } catch (Exception ex) { MessageBox.Show("Памылка ўсталёўкі спраўджвання абнаўленняў перакладу Windows 7\nПаведаміце, калі ласка, на [email protected] :\n" + ex.Message, "Памылка", MessageBoxButtons.OK, MessageBoxIcon.Error); Environment.Exit(1); } Environment.Exit(0); }
private void AddTaskOptions(ITaskDefinition iTaskDefinition, ScheduledJobOptions jobOptions) { _TASK_RUNLEVEL variable; iTaskDefinition.Settings.DisallowStartIfOnBatteries = !jobOptions.StartIfOnBatteries; iTaskDefinition.Settings.StopIfGoingOnBatteries = jobOptions.StopIfGoingOnBatteries; iTaskDefinition.Settings.WakeToRun = jobOptions.WakeToRun; iTaskDefinition.Settings.RunOnlyIfIdle = !jobOptions.StartIfNotIdle; iTaskDefinition.Settings.IdleSettings.StopOnIdleEnd = jobOptions.StopIfGoingOffIdle; iTaskDefinition.Settings.IdleSettings.RestartOnIdle = jobOptions.RestartOnIdleResume; iTaskDefinition.Settings.IdleSettings.IdleDuration = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobOptions.IdleDuration); iTaskDefinition.Settings.IdleSettings.WaitTimeout = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobOptions.IdleTimeout); iTaskDefinition.Settings.Hidden = !jobOptions.ShowInTaskScheduler; iTaskDefinition.Settings.RunOnlyIfNetworkAvailable = !jobOptions.RunWithoutNetwork; iTaskDefinition.Settings.AllowDemandStart = !jobOptions.DoNotAllowDemandStart; iTaskDefinition.Settings.MultipleInstances = this.ConvertFromMultiInstances(jobOptions.MultipleInstancePolicy); TaskScheduler.IPrincipal principal = iTaskDefinition.Principal; if (jobOptions.RunElevated) { variable = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST; } else { variable = _TASK_RUNLEVEL.TASK_RUNLEVEL_LUA; } principal.RunLevel = variable; }
private void AddTaskAction(ITaskDefinition iTaskDefinition, ScheduledJobDefinition definition) { IExecAction pSExecutionPath = iTaskDefinition.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC) as IExecAction; pSExecutionPath.Id = "StartPowerShellJob"; pSExecutionPath.Path = definition.PSExecutionPath; pSExecutionPath.Arguments = definition.PSExecutionArgs; }
/// <summary> /// Creates a new task in WTS with information from ScheduledJobDefinition. /// </summary> /// <param name="definition">ScheduledJobDefinition</param> public void CreateTask( ScheduledJobDefinition definition) { if (definition == null) { throw new PSArgumentNullException("definition"); } // Create task definition ITaskDefinition iTaskDefinition = _taskScheduler.NewTask(0); // Add task options. AddTaskOptions(iTaskDefinition, definition.Options); // Add task triggers. foreach (ScheduledJobTrigger jobTrigger in definition.JobTriggers) { AddTaskTrigger(iTaskDefinition, jobTrigger); } // Add task action. AddTaskAction(iTaskDefinition, definition); // Create a security descriptor for the current user so that only the user // (and Local System account) can see/access the registered task. string startSddl = "D:P(A;;GA;;;SY)(A;;GA;;;BA)"; // DACL Allow Generic Access to System and BUILTIN\Administrators. System.Security.Principal.SecurityIdentifier userSid = System.Security.Principal.WindowsIdentity.GetCurrent().User; CommonSecurityDescriptor SDesc = new CommonSecurityDescriptor(false, false, startSddl); SDesc.DiscretionaryAcl.AddAccess(AccessControlType.Allow, userSid, 0x10000000, InheritanceFlags.None, PropagationFlags.None); string sddl = SDesc.GetSddlForm(AccessControlSections.All); // Register this new task with the Task Scheduler. if (definition.Credential == null) { // Register task to run as currently logged on user. _iRootFolder.RegisterTaskDefinition( definition.Name, iTaskDefinition, (int)_TASK_CREATION.TASK_CREATE, null, // User name null, // Password _TASK_LOGON_TYPE.TASK_LOGON_S4U, sddl); } else { // Register task to run under provided user account/credentials. _iRootFolder.RegisterTaskDefinition( definition.Name, iTaskDefinition, (int)_TASK_CREATION.TASK_CREATE, definition.Credential.UserName, GetCredentialPassword(definition.Credential), _TASK_LOGON_TYPE.TASK_LOGON_PASSWORD, sddl); } }
public void UpdateTask(ScheduledJobDefinition definition) { if (definition != null) { ITaskDefinition enabled = this.FindTask(definition.Name); this.AddTaskOptions(enabled, definition.Options); enabled.Settings.Enabled = definition.Enabled; enabled.Triggers.Clear(); foreach (ScheduledJobTrigger jobTrigger in definition.JobTriggers) { this.AddTaskTrigger(enabled, jobTrigger); } enabled.Actions.Clear(); this.AddTaskAction(enabled, definition); if (definition.Credential != null) { this._iRootFolder.RegisterTaskDefinition(definition.Name, enabled, 4, definition.Credential.UserName, this.GetCredentialPassword(definition.Credential), _TASK_LOGON_TYPE.TASK_LOGON_PASSWORD, null); return; } else { this._iRootFolder.RegisterTaskDefinition(definition.Name, enabled, 4, null, null, _TASK_LOGON_TYPE.TASK_LOGON_S4U, null); return; } } else { throw new PSArgumentNullException("definition"); } }
static void Main(string[] args) { var scheduler = new TaskSchedulerClass(); scheduler.Connect(null, null, null, null); ITaskDefinition task = scheduler.NewTask(0); task.RegistrationInfo.Author = "DCOM Productions"; task.RegistrationInfo.Description = "Demo"; ILogonTrigger trigger = (ILogonTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON); trigger.Id = "Logon Demo"; IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC); action.Id = "Delete"; action.Path = "c:\\delete.exe"; // Or similar path action.WorkingDirectory = "c:\\"; // Working path action.Arguments = "c:\\killme.txt"; // Path to your file ITaskFolder root = scheduler.GetFolder("\\"); IRegisteredTask regTask = root.RegisterTaskDefinition("Demo", task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, ""); //Force run task //IRunningTask runTask = regTask.Run(null); }
//Setting Task Definition private void SetTaskDefinition() { try { objTaskDef = objScheduler.NewTask(0); //Registration Info for task //Name of the task Author objTaskDef.RegistrationInfo.Author = "AuthorName"; //Description of the task objTaskDef.RegistrationInfo.Description = "CreatBackupBase1C"; //Registration date of the task objTaskDef.RegistrationInfo.Date = DateTime.Today.ToString("yyyy-MM-ddTHH:mm:ss"); //Date format //Settings for task //Thread Priority objTaskDef.Settings.Priority = 7; //Enabling the task objTaskDef.Settings.Enabled = true; //To hide/show the task objTaskDef.Settings.Hidden = false; //Execution Time Lmit for task objTaskDef.Settings.ExecutionTimeLimit = "PT10M"; //10 minutes //Specifying no need of network connection objTaskDef.Settings.RunOnlyIfNetworkAvailable = false; } catch (Exception ex) { throw ex; } }
private void CreateSchedulerTask() { ITaskDefinition definition = scheduler.NewTask(0); definition.RegistrationInfo.Description = "This task starts the Open Hardware Monitor on Windows startup."; definition.Principal.RunLevel = TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST; definition.Settings.DisallowStartIfOnBatteries = false; definition.Settings.StopIfGoingOnBatteries = false; definition.Settings.ExecutionTimeLimit = "PT0S"; ILogonTrigger trigger = (ILogonTrigger)definition.Triggers.Create( TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON); IExecAction action = (IExecAction)definition.Actions.Create( TASK_ACTION_TYPE.TASK_ACTION_EXEC); action.Path = Application.ExecutablePath; action.WorkingDirectory = Path.GetDirectoryName(Application.ExecutablePath); ITaskFolder root = scheduler.GetFolder("\\"); ITaskFolder folder; try { folder = root.GetFolder("Open Hardware Monitor"); } catch (FileNotFoundException) { folder = root.CreateFolder("Open Hardware Monitor", ""); } folder.RegisterTaskDefinition("Startup", definition, (int)TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, ""); }
private void GetItemsFromTaskDefenition(ITaskDefinition defenition) { var actions = defenition.Actions; _comObjects.Push(actions); foreach (IAction action in actions) { _comObjects.Push(action); if (action.Type == _TASK_ACTION_TYPE.TASK_ACTION_EXEC) { IExecAction execaction = (IExecAction)action; if (!string.IsNullOrEmpty(execaction.Path)) { var linfo = _pathResolver.ResolvePath( execaction.Path, execaction.WorkingDirectory, execaction.Arguments, LaunchInfoSource.TaskSheduler); _items.Add(linfo); } } } }
/// <summary> /// Converts the Business Entity to COM Representation of ScheduledTask /// </summary> /// <param name="task">Scheduled task Business Entity</param> /// <returns>COM entity of a scheduled Task</returns> private ITaskDefinition TransformToRegisteredTask(ScheduledTask task) { ITaskDefinition taskDefinition = this.taskService.NewTask(0); taskDefinition.RegistrationInfo.Description = task.Description; taskDefinition.RegistrationInfo.Author = task.Author; taskDefinition.Settings.Enabled = task.Settings.Enabled; taskDefinition.Settings.Hidden = task.Settings.Hidden; taskDefinition.Settings.Compatibility = _TASK_COMPATIBILITY.TASK_COMPATIBILITY_V2_1; if (task.Settings.StopTaskWhenRunsLonger) { // this is the format needed by COM taskDefinition.Settings.ExecutionTimeLimit = ConvertToCOMTimeSpanRepresentation(task.Settings.ExecutionTimeLimit); } if (task.Conditions.RunOnlyIfIdle) { taskDefinition.Settings.RunOnlyIfIdle = task.Conditions.RunOnlyIfIdle; // this is the format needed by COM taskDefinition.Settings.IdleSettings.IdleDuration = ConvertToCOMTimeSpanRepresentation(task.Conditions.IdleDurationToStartTaskWhenSystemIsIdle); } // ADD Triggers ConfigureTriggers(taskDefinition, task); // ADD Actions ConfigureActions(taskDefinition, task); return(taskDefinition); }
/// <summary> /// Creates a scheduled task /// </summary> /// <param name="task">Scheduled Task object containing all configured iformation</param> /// <returns>True if task gets created successfully</returns> /// <exception cref="TaskScheduler.Exceptions.InvalidTaskNameException">Thrown when task name has invalid/illegal characters</exception> public bool CreateTask(ScheduledTask task) { if (task.Name.Contains(Constants.TaskPathSeparator)) { throw new InvalidTaskNameException(); } try { this.ConnectTaskSchedulerService(); ITaskDefinition definition = this.TransformToRegisteredTask(task); // creating this task in the root Folder // you may choose to create in sub-folders. // Create SubFolder under RootFolder, if you require ITaskFolder rootFolder = this.taskService.GetFolder(Constants.TaskPathSeparator); // 6 as flags (3rd argument) means this task can be created or updated ["CreateOrUpdate" flag] // Add the task to the RootFolder // if Name id empty or null, System will create a task with name as GUID rootFolder.RegisterTaskDefinition(task.Name, definition, 6, null, null, _TASK_LOGON_TYPE.TASK_LOGON_NONE, null); } catch (Exception exception) { Logger.LogError(Constants.TaskCreateError, exception); throw; } return(true); }
/// <summary> /// Converts the Scheduled Task COM representation to Business Entity /// </summary> /// <param name="task">COM Scheduled Task</param> /// <returns>An instance of Scheduled Task</returns> private static ScheduledTask TransformToTask(IRegisteredTask task) { ScheduledTask scheduledTask = new ScheduledTask(); scheduledTask.Name = task.Name; scheduledTask.CurrentState = task.State.ToString(); scheduledTask.TaskPath = task.Path; scheduledTask.NextRunTime = task.NextRunTime; scheduledTask.LastRunTime = task.LastRunTime; scheduledTask.LastRunResults = task.LastTaskResult.ToString(); ITaskDefinition definition = task.Definition; ITaskSettings settings = definition.Settings; scheduledTask.Priority = settings.Priority; scheduledTask.Settings = new Settings(); scheduledTask.Settings.Enabled = settings.Enabled; scheduledTask.Settings.Hidden = settings.Hidden; IRegistrationInfo registrationInfo = definition.RegistrationInfo; scheduledTask.Description = registrationInfo.Description; scheduledTask.Author = registrationInfo.Author; return(scheduledTask); }
/// <summary> /// Creates Actions /// </summary> /// <param name="taskDefinition">Task Definition to which triggers should be added</param> /// <param name="task">Task containing trigger information</param> private static void ConfigureActions(ITaskDefinition taskDefinition, ScheduledTask task) { IActionCollection actions = taskDefinition.Actions; if (task.Actions != null) { foreach (Entities.Action actionInfo in task.Actions) { _TASK_ACTION_TYPE actionType = MapActionType(actionInfo.Type); IAction action = actions.Create(actionType); switch (actionType) { case _TASK_ACTION_TYPE.TASK_ACTION_EXEC: ConfigureExecAction(action, actionInfo); break; case _TASK_ACTION_TYPE.TASK_ACTION_SEND_EMAIL: ConfigureEmailAction(action, actionInfo); break; case _TASK_ACTION_TYPE.TASK_ACTION_SHOW_MESSAGE: ConfigureShowMessageAction(action, actionInfo); break; } } } }
// Install the UAC bypass CosmosTask. This must be performed while the program is running under // administrator credentials with elevation. void InstallScheduledTask() { ITaskService xService = new TaskScheduler.TaskScheduler(); xService.Connect(); ITaskFolder xFolder = xService.GetFolder(@"\"); IRegisteredTask xTask = TryGetInstallScheduledTask(xFolder); if (null != xTask) { // The first parameter MUST NOT be prefixed with the folder path. xFolder.DeleteTask(InstallScheduledTaskName, 0); } ITaskDefinition xTaskDef = xService.NewTask(0); xTaskDef.RegistrationInfo.Description = "Cosmos DevKit UAC Bypass"; xTaskDef.RegistrationInfo.Author = "Cosmos Group"; xTaskDef.Settings.Compatibility = _TASK_COMPATIBILITY.TASK_COMPATIBILITY_V2_1; xTaskDef.Settings.DisallowStartIfOnBatteries = false; xTaskDef.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST; IActionCollection xActions = xTaskDef.Actions; IAction xAction = xActions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC); IExecAction xExecAction = xAction as IExecAction; xExecAction.Path = mSetupPath; xExecAction.Arguments = @"/SILENT"; // 6 = task can be created or updated ["CreateOrUpdate" flag] // if Name id empty or null, System will create a task with name as GUID xTask = xFolder.RegisterTaskDefinition(InstallScheduledTaskName, xTaskDef, 6, null, null, _TASK_LOGON_TYPE.TASK_LOGON_NONE, null); }
private ScheduledJobOptions CreateJobOptions(ITaskDefinition iTaskDefinition) { ITaskSettings settings = iTaskDefinition.Settings; TaskScheduler.IPrincipal principal = iTaskDefinition.Principal; return(new ScheduledJobOptions(!settings.DisallowStartIfOnBatteries, settings.StopIfGoingOnBatteries, settings.WakeToRun, !settings.RunOnlyIfIdle, settings.IdleSettings.StopOnIdleEnd, settings.IdleSettings.RestartOnIdle, this.ParseWTSTime(settings.IdleSettings.IdleDuration), this.ParseWTSTime(settings.IdleSettings.WaitTimeout), !settings.Hidden, principal.RunLevel == _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST, !settings.RunOnlyIfNetworkAvailable, !settings.AllowDemandStart, this.ConvertToMultiInstances(settings))); }
static public bool SkipUacEnable(string taskName, bool is_enable) { try { TaskScheduler.TaskScheduler service = new TaskScheduler.TaskScheduler(); service.Connect(); ITaskFolder folder = service.GetFolder(@"\"); // root if (is_enable) { string exePath = System.Reflection.Assembly.GetExecutingAssembly().Location; string appPath = Path.GetDirectoryName(exePath); ITaskDefinition task = service.NewTask(0); task.RegistrationInfo.Author = "WuMgr"; task.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST; task.Settings.AllowHardTerminate = false; task.Settings.StartWhenAvailable = false; task.Settings.DisallowStartIfOnBatteries = false; task.Settings.StopIfGoingOnBatteries = false; task.Settings.MultipleInstances = _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL; task.Settings.ExecutionTimeLimit = "PT0S"; IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC); action.Path = exePath; action.WorkingDirectory = appPath; action.Arguments = "-NoUAC $(Arg0)"; IRegisteredTask registered_task = folder.RegisterTaskDefinition(taskName, task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN); if (registered_task == null) { return(false); } // Note: if we run as UWP we need to adjust the file permissions for this workaround to work if (UwpFunc.IsRunningAsUwp()) { if (!FileOps.TakeOwn(exePath)) { return(false); } FileSecurity ac = File.GetAccessControl(exePath); ac.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(FileOps.SID_Worls), FileSystemRights.ReadAndExecute, AccessControlType.Allow)); File.SetAccessControl(exePath, ac); } } else { folder.DeleteTask(taskName, 0); } } catch (Exception err) { AppLog.Line("Enable SkipUAC Error {0}", err.ToString()); return(false); } return(true); }
/// <summary> /// 创建计划任务 /// </summary> /// <param name="creator">创建人</param> /// <param name="taskName">计划任务名称</param> /// <param name="path">执行文件的路径</param> /// <param name="intervalMintue">计划任务执行的频率(分钟)</param> /// <param name="startBoundary">开始时间(默认是DateTime.MinValue)</param> /// <param name="endBoundary">结束时间(默认是DateTime.MinValue)</param> /// <param name="description">备注</param> /// <param name="runOnlyIfIdle">仅当计算机空闲下才执行</param> /// <returns></returns> public static _TASK_STATE CreateTaskScheduler(string creator, string taskName, string path, int intervalMintue, DateTime startBoundary, DateTime endBoundary, bool runOnlyIfIdle = false, string description = "") { try { if (IsExists(taskName)) { DeleteTask(taskName); } //new scheduler TaskSchedulerClass scheduler = new TaskSchedulerClass(); //pc-name/ip,username,domain,password scheduler.Connect(null, null, null, null); //get scheduler folder ITaskFolder folder = scheduler.GetFolder("\\"); //set base attr ITaskDefinition task = scheduler.NewTask(0); task.RegistrationInfo.Author = creator; //creator task.RegistrationInfo.Description = description; //description //set trigger (IDailyTrigger ITimeTrigger) ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME); tt.Repetition.Interval = GetInterval(intervalMintue);// format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器 if (startBoundary > DateTime.MinValue) { tt.StartBoundary = startBoundary.ToString("yyyy-MM-ddTHH:mm:ss");//start time } else { tt.StartBoundary = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss");//start time } if (startBoundary > DateTime.MinValue) { tt.EndBoundary = startBoundary.ToString("yyyy-MM-ddTHH:mm:ss");; } //set action IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC); action.Path = path; //计划任务调用的程序路径 task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时 task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行 task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行 IRegisteredTask regTask = folder.RegisterTaskDefinition(taskName, task, (int)_TASK_CREATION.TASK_CREATE, null, //user null, // password _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, ""); IRunningTask runTask = regTask.Run(null); return(runTask.State); } catch (Exception ex) { throw ex; } }
internal override void Bind(ITaskDefinition iTaskDef) { base.Bind(iTaskDef); if (_nvc != null) { _nvc.Bind(((IEventTrigger)base._v2Trigger).ValueQueries); } }
internal override void Bind(ITaskDefinition iTaskDef) { base.Bind(iTaskDef); if (nvc != null) { nvc.Bind(((IEmailAction)iAction).HeaderFields); } }
/// <summary> /// 创建任务 /// </summary> void CreateTask() { try { string creator = "HST"; string taskName = TaskName; string path = Process.GetCurrentProcess().MainModule.FileName; string interval = "PT24H0M"; //new scheduler TaskSchedulerClass scheduler = new TaskSchedulerClass(); //pc-name/ip,username,domain,password scheduler.Connect(null, null, null, null); //get scheduler folder ITaskFolder folder = scheduler.GetFolder("\\"); //set base attr ITaskDefinition task = scheduler.NewTask(0); task.RegistrationInfo.Author = creator; //creator task.RegistrationInfo.Description = "Boot BudSSH"; //description task.RegistrationInfo.Date = DateTimeUtil.GetTaskFormatTime(DateTime.Now); //set trigger (IDailyTrigger ITimeTrigger) ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME); tt.Repetition.Interval = interval;// format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器 Config config = ConfigManager.GetCurrentConfig(); var date = DateTime.Parse(config.SSHBootTime); tt.StartBoundary = DateTimeUtil.GetTaskFormatTime(date);// "2015-04-09T14:27:25";//start time //set action IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC); action.Path = path; task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时 task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行 task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行 IRegisteredTask regTask = folder.RegisterTaskDefinition(taskName, task, (int)_TASK_CREATION.TASK_CREATE, null, //user null, // password _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, ""); if (regTask.State != _TASK_STATE.TASK_STATE_READY && regTask.State != _TASK_STATE.TASK_STATE_RUNNING) { IRunningTask runTask = regTask.Run(null); } logger.Info("regTask.State: " + regTask.State); } catch (System.Exception ex) { logger.Error("Create Task Error"); throw ex; } }
internal override void AddToTask(ITaskDefinition taskDefinition) { IWeeklyTrigger variable = base.Create <IWeeklyTrigger>(taskDefinition); variable.WeeksInterval = this._weeksInterval; variable.DaysOfWeek = ( from x in this._recurDays.Distinct <DayOfWeek>() select this._bitsForWeekDays[x]).Aggregate <short>((short x, short y) => (short)(x | y)); }
/// <summary> /// Releases all resources used by this class. /// </summary> public void Dispose() { if (v2Coll != null) { Marshal.ReleaseComObject(v2Coll); } v2Def = null; v1Task = null; }
public async Task HandleAsync(ITaskDefinition <TIdentifier> taskDefinition, Exception exception) { var taskDefinitionState = await GetTaskDefinitionState(taskDefinition.Id); taskDefinitionState.Disabled = true; await taskDefinitionStateWriter.WriteAsync(taskDefinitionState); await faultReporter.ReportAsync(taskDefinition, exception, true); }
/// <summary> /// Updates an existing task in WTS with information from /// ScheduledJobDefinition. /// </summary> /// <param name="definition">ScheduledJobDefinition</param> public void UpdateTask( ScheduledJobDefinition definition) { if (definition == null) { throw new PSArgumentNullException("definition"); } // Get task to update. ITaskDefinition iTaskDefinition = FindTask(definition.Name); // Replace options. AddTaskOptions(iTaskDefinition, definition.Options); // Set enabled state. iTaskDefinition.Settings.Enabled = definition.Enabled; // Replace triggers. iTaskDefinition.Triggers.Clear(); foreach (ScheduledJobTrigger jobTrigger in definition.JobTriggers) { AddTaskTrigger(iTaskDefinition, jobTrigger); } // Replace action. iTaskDefinition.Actions.Clear(); AddTaskAction(iTaskDefinition, definition); // Register updated task. if (definition.Credential == null) { // Register task to run as currently logged on user. _iRootFolder.RegisterTaskDefinition( definition.Name, iTaskDefinition, (int)_TASK_CREATION.TASK_UPDATE, null, // User name null, // Password _TASK_LOGON_TYPE.TASK_LOGON_S4U, null); } else { // Register task to run under provided user account/credentials. _iRootFolder.RegisterTaskDefinition( definition.Name, iTaskDefinition, (int)_TASK_CREATION.TASK_UPDATE, definition.Credential.UserName, GetCredentialPassword(definition.Credential), _TASK_LOGON_TYPE.TASK_LOGON_PASSWORD, null); } }
/// <summary> /// Returns a boolean indicating whether the job/task is enabled /// in the Task Scheduler. /// </summary> /// <param name="taskId"></param> /// <returns></returns> public bool GetTaskEnabled( string taskId) { if (string.IsNullOrEmpty(taskId)) { throw new PSArgumentException("taskId"); } ITaskDefinition iTaskDefinition = FindTask(taskId); return(iTaskDefinition.Settings.Enabled); }
private void AddTaskAction( ITaskDefinition iTaskDefinition, ScheduledJobDefinition definition) { IExecAction iExecAction = iTaskDefinition.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC) as IExecAction; Debug.Assert(iExecAction != null); iExecAction.Id = ScheduledJobTaskActionId; iExecAction.Path = definition.PSExecutionPath; iExecAction.Arguments = definition.PSExecutionArgs; }
/// <summary> /// Retrieves options for the provided task Id. /// </summary> /// <param name="taskId">Task Id</param> /// <exception cref="ScheduledJobException">Task not found.</exception> /// <returns>ScheduledJobOptions</returns> public ScheduledJobOptions GetJobOptions( string taskId) { if (string.IsNullOrEmpty(taskId)) { throw new PSArgumentException("taskId"); } ITaskDefinition iTaskDefinition = FindTask(taskId); return(CreateJobOptions(iTaskDefinition)); }
public void addWakeUpTask(int sT) { //rootFolder.CreateFolder("", &newFolder); task = scheduler.NewTask(0); task.Settings.Enabled = true; task.Settings.WakeToRun = true; task.Settings.StopIfGoingOnBatteries = false; task.Settings.RunOnlyIfIdle = false; task.Settings.DisallowStartIfOnBatteries = false; task.Settings.IdleSettings.StopOnIdleEnd = false; task.Settings.RestartCount = 5; task.Settings.RestartInterval = "PT1M"; task.Settings.StartWhenAvailable = true; task.Settings.Priority = 0; task.Settings.MultipleInstances = _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL; task.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST; task.Principal.LogonType = _TASK_LOGON_TYPE.TASK_LOGON_SERVICE_ACCOUNT; task.Principal.UserId = "System"; action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC); //action.Path = typeof(SayHello.Form1).Assembly.Location; action.Path = @"c:\windows\notepad.exe"; //action.Path = @"C:\Users\sagatsum\Documents\Visual Studio 2010\Projects\FakeISCTConsole\FakeISCTConsole\bin\Release\FakeISCTConsole.exe"; //action.WorkingDirectory = Path.GetDirectoryName(typeof(SayHello.Form1).Assembly.Location); //action.WorkingDirectory = @"C:\Users\sagatsum\Documents\Visual Studio 2010\Projects\FakeISCTConsole\FakeISCTConsole\bin\Release"; trigger = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME); //trigger.StateChange = _TASK_SESSION_STATE_CHANGE_TYPE.TASK_SESSION_UNLOCK; trigger.Enabled = true; trigger.StartBoundary = (DateTime.Now.AddSeconds(sT)).ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss"); task.RegistrationInfo.Author = "Shintaro Agatsuma"; task.RegistrationInfo.Description = "Fake iSCT Task."; try { IRegisteredTask ticket = rootFolder.RegisterTaskDefinition("Fake iSCT Wake Up", task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_S4U, null); eventLog.WriteEntry("Task Successfully added"); } catch (Exception e) { eventLog.WriteEntry("Failed to add a task: " + e.Message); } }
internal virtual void Bind(ITaskDefinition iTaskDef) { var o = iTaskDef.Triggers; _v2Trigger = o.Create(_ttype); Marshal.ReleaseComObject(o); foreach (string str in unboundValues.Keys) { try { var obj2 = unboundValues[str]; CheckBindValue(str, ref obj2); _v2Trigger.GetType().InvokeMember(str, BindingFlags.SetProperty, null, _v2Trigger, new object[] { obj2 }); } catch (TargetInvocationException ex) { throw ex.InnerException; } catch { } } unboundValues.Clear(); unboundValues = null; _repititionPattern = new RepetitionPattern(this); _repititionPattern.Bind(); }
internal override void Bind(ITaskDefinition iTaskDef) { base.Bind(iTaskDef); if (nvc != null) { nvc.Bind(((IEventTrigger)v2Trigger).ValueQueries); } }
internal TaskDefinition(ITaskDefinition iDef) { _v1Name = string.Empty; _v2Def = iDef; }
internal virtual void Bind(ITaskDefinition iTaskDef) { var iActions = iTaskDef.Actions; switch (GetType().Name) { case "ComHandlerAction": iAction = iActions.Create(TaskActionType.ComHandler); break; case "ExecAction": iAction = iActions.Create(TaskActionType.Execute); break; case "EmailAction": iAction = iActions.Create(TaskActionType.SendEmail); break; case "ShowMessageAction": iAction = iActions.Create(TaskActionType.ShowMessage); break; default: throw new ArgumentException(); } Marshal.ReleaseComObject(iActions); foreach (var key in unboundValues.Keys) { try { iAction.GetType().InvokeMember(key, BindingFlags.SetProperty, null, iAction, new[] { unboundValues[key] }); } catch (TargetInvocationException tie) { throw tie.InnerException; } catch { } } unboundValues.Clear(); }
/// <summary> /// Creates a new WTS trigger based on the provided ScheduledJobTrigger object /// and adds it to the provided ITaskDefinition object. /// </summary> /// <param name="iTaskDefinition">ITaskDefinition</param> /// <param name="jobTrigger">ScheduledJobTrigger</param> private void AddTaskTrigger( ITaskDefinition iTaskDefinition, ScheduledJobTrigger jobTrigger) { ITrigger iTrigger = null; switch (jobTrigger.Frequency) { case TriggerFrequency.AtStartup: { iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_BOOT); IBootTrigger iBootTrigger = iTrigger as IBootTrigger; Debug.Assert(iBootTrigger != null); iBootTrigger.Delay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture); iTrigger.Enabled = jobTrigger.Enabled; } break; case TriggerFrequency.AtLogon: { iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON); ILogonTrigger iLogonTrigger = iTrigger as ILogonTrigger; Debug.Assert(iLogonTrigger != null); iLogonTrigger.UserId = ScheduledJobTrigger.IsAllUsers(jobTrigger.User) ? null : jobTrigger.User; iLogonTrigger.Delay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture); iTrigger.Enabled = jobTrigger.Enabled; } break; case TriggerFrequency.Once: { iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME); ITimeTrigger iTimeTrigger = iTrigger as ITimeTrigger; Debug.Assert(iTimeTrigger != null); iTimeTrigger.RandomDelay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); // Time trigger repetition. if (jobTrigger.RepetitionInterval != null && jobTrigger.RepetitionDuration != null) { iTimeTrigger.Repetition.Interval = ConvertTimeSpanToWTSString(jobTrigger.RepetitionInterval.Value); if (jobTrigger.RepetitionDuration.Value == TimeSpan.MaxValue) { iTimeTrigger.Repetition.StopAtDurationEnd = false; } else { iTimeTrigger.Repetition.StopAtDurationEnd = true; iTimeTrigger.Repetition.Duration = ConvertTimeSpanToWTSString(jobTrigger.RepetitionDuration.Value); } } iTrigger.StartBoundary = ConvertDateTimeToString(jobTrigger.At); iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture); iTrigger.Enabled = jobTrigger.Enabled; } break; case TriggerFrequency.Daily: { iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY); IDailyTrigger iDailyTrigger = iTrigger as IDailyTrigger; Debug.Assert(iDailyTrigger != null); iDailyTrigger.RandomDelay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); iDailyTrigger.DaysInterval = (short)jobTrigger.Interval; iTrigger.StartBoundary = ConvertDateTimeToString(jobTrigger.At); iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture); iTrigger.Enabled = jobTrigger.Enabled; } break; case TriggerFrequency.Weekly: { iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_WEEKLY); IWeeklyTrigger iWeeklyTrigger = iTrigger as IWeeklyTrigger; Debug.Assert(iWeeklyTrigger != null); iWeeklyTrigger.RandomDelay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); iWeeklyTrigger.WeeksInterval = (short)jobTrigger.Interval; iWeeklyTrigger.DaysOfWeek = ConvertDaysOfWeekToMask(jobTrigger.DaysOfWeek); iTrigger.StartBoundary = ConvertDateTimeToString(jobTrigger.At); iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture); iTrigger.Enabled = jobTrigger.Enabled; } break; } }
private void AddTaskTrigger(ITaskDefinition iTaskDefinition, ScheduledJobTrigger jobTrigger) { ITrigger str; string user; TriggerFrequency frequency = jobTrigger.Frequency; switch (frequency) { case TriggerFrequency.Once: { str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME); ITimeTrigger wTSString = str as ITimeTrigger; wTSString.RandomDelay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); TimeSpan? repetitionInterval = jobTrigger.RepetitionInterval; if (repetitionInterval.HasValue) { TimeSpan? repetitionDuration = jobTrigger.RepetitionDuration; if (repetitionDuration.HasValue) { TimeSpan? nullable = jobTrigger.RepetitionInterval; wTSString.Repetition.Interval = ScheduledJobWTS.ConvertTimeSpanToWTSString(nullable.Value); TimeSpan? repetitionDuration1 = jobTrigger.RepetitionDuration; if (repetitionDuration1.Value != TimeSpan.MaxValue) { wTSString.Repetition.StopAtDurationEnd = true; TimeSpan? nullable1 = jobTrigger.RepetitionDuration; wTSString.Repetition.Duration = ScheduledJobWTS.ConvertTimeSpanToWTSString(nullable1.Value); } else { wTSString.Repetition.StopAtDurationEnd = false; } } } str.StartBoundary = ScheduledJobWTS.ConvertDateTimeToString(jobTrigger.At); int id = jobTrigger.Id; str.Id = id.ToString(CultureInfo.InvariantCulture); str.Enabled = jobTrigger.Enabled; return; } case TriggerFrequency.Daily: { str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY); IDailyTrigger interval = str as IDailyTrigger; interval.RandomDelay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); interval.DaysInterval = (short)jobTrigger.Interval; str.StartBoundary = ScheduledJobWTS.ConvertDateTimeToString(jobTrigger.At); int num = jobTrigger.Id; str.Id = num.ToString(CultureInfo.InvariantCulture); str.Enabled = jobTrigger.Enabled; return; } case TriggerFrequency.Weekly: { str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_WEEKLY); IWeeklyTrigger mask = str as IWeeklyTrigger; mask.RandomDelay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); mask.WeeksInterval = (short)jobTrigger.Interval; mask.DaysOfWeek = ScheduledJobWTS.ConvertDaysOfWeekToMask(jobTrigger.DaysOfWeek); str.StartBoundary = ScheduledJobWTS.ConvertDateTimeToString(jobTrigger.At); int id1 = jobTrigger.Id; str.Id = id1.ToString(CultureInfo.InvariantCulture); str.Enabled = jobTrigger.Enabled; return; } case TriggerFrequency.AtLogon: { str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON); ILogonTrigger variable = str as ILogonTrigger; ILogonTrigger variable1 = variable; if (ScheduledJobTrigger.IsAllUsers(jobTrigger.User)) { user = null; } else { user = jobTrigger.User; } variable1.UserId = user; variable.Delay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); int num1 = jobTrigger.Id; str.Id = num1.ToString(CultureInfo.InvariantCulture); str.Enabled = jobTrigger.Enabled; return; } case TriggerFrequency.AtStartup: { str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_BOOT); IBootTrigger wTSString1 = str as IBootTrigger; wTSString1.Delay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay); int id2 = jobTrigger.Id; str.Id = id2.ToString(CultureInfo.InvariantCulture); str.Enabled = jobTrigger.Enabled; return; } default: { return; } } }
internal virtual void Bind(ITaskDefinition iTaskDef) { var iTriggers = iTaskDef.Triggers; v2Trigger = iTriggers.Create(ttype); Marshal.ReleaseComObject(iTriggers); foreach (var key in unboundValues.Keys) { try { var o = unboundValues[key]; CheckBindValue(key, ref o); v2Trigger.GetType().InvokeMember(key, BindingFlags.SetProperty, null, v2Trigger, new[] {o}); } catch (TargetInvocationException tie) { throw tie.InnerException; } catch { } } unboundValues.Clear(); unboundValues = null; repititionPattern = new RepetitionPattern(this); repititionPattern.Bind(); }
public IRegisteredTask RegisterTaskDefinition (string Path, ITaskDefinition pDefinition, int flags, object UserId, object password, _TASK_LOGON_TYPE LogonType, object sddl) { throw new NotImplementedException (); }
private ScheduledJobOptions CreateJobOptions( ITaskDefinition iTaskDefinition) { ITaskSettings iTaskSettings = iTaskDefinition.Settings; IPrincipal iPrincipal = iTaskDefinition.Principal; return new ScheduledJobOptions( !iTaskSettings.DisallowStartIfOnBatteries, iTaskSettings.StopIfGoingOnBatteries, iTaskSettings.WakeToRun, !iTaskSettings.RunOnlyIfIdle, iTaskSettings.IdleSettings.StopOnIdleEnd, iTaskSettings.IdleSettings.RestartOnIdle, ParseWTSTime(iTaskSettings.IdleSettings.IdleDuration), ParseWTSTime(iTaskSettings.IdleSettings.WaitTimeout), !iTaskSettings.Hidden, iPrincipal.RunLevel == _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST, !iTaskSettings.RunOnlyIfNetworkAvailable, !iTaskSettings.AllowDemandStart, ConvertToMultiInstances(iTaskSettings)); }