public void OnNext(IRunningTask task)
{
Log.Log(Level.Info,
"TaskRuntime: {0} expect {1}",
task.Id, _taskId);
if (!_taskId.Equals(task.Id))
{
throw new DriverSideFailure($"Task ID {task.Id} not equal expected ID {_taskId}");
}
switch (_failTaskName)
{
case "FailTaskMsg":
Log.Log(Level.Info, "TaskRuntime: Send message: {0}", task);
task.Send(new byte[0]);
break;
case "FailTaskSuspend":
Log.Log(Level.Info, "TaskRuntime: Suspend: {0}", task);
task.Suspend();
break;
case "FailTaskStop":
case "FailTaskClose":
Log.Log(Level.Info, "TaskRuntime: Stop/Close: {0}", task);
task.Dispose();
break;
default:
break;
}
}
/// <summary>
/// IRunningTask handler. The method is called when a task is running. The following action will be taken based on the system state:
/// Case SubmittingTasks
/// Add it to RunningTasks and set task state to TaskRunning
/// When all the tasks are running, change system state to TasksRunning
/// Case ShuttingDown/Fail
/// Call TaskManager to record RunningTask during SystemFailure
/// Other cases - not expected
/// </summary>
/// <param name="runningTask"></param>
public void OnNext(IRunningTask runningTask)
{
Logger.Log(Level.Info, "Received IRunningTask {0} from endpoint {1} at SystemState {2} retry # {3}.", runningTask.Id, GetEndPointFromTaskId(runningTask.Id), _systemState.CurrentState, _numberOfRetries);
lock (_lock)
{
using (Logger.LogFunction("IMRUDriver::IRunningTask"))
{
switch (_systemState.CurrentState)
{
case SystemState.SubmittingTasks:
_taskManager.RecordRunningTask(runningTask);
if (_taskManager.AreAllTasksRunning())
{
_systemState.MoveNext(SystemStateEvent.AllTasksAreRunning);
Logger.Log(Level.Info,
"All tasks are running, SystemState {0}",
_systemState.CurrentState);
}
break;
case SystemState.ShuttingDown:
case SystemState.Fail:
_taskManager.RecordRunningTaskDuringSystemFailure(runningTask, TaskManager.CloseTaskByDriver);
break;
default:
UnexpectedState(runningTask.Id, "IRunningTask");
break;
}
}
}
}
private void btnCreateTask_Click(object sender, EventArgs e)
{
try
{
objScheduler = new TaskScheduler();
objScheduler.Connect();
//Setting Task Definition
SetTaskDefinition();
//Setting Task Trigger Information
SetTriggerInfo();
//Setting Task Action Information
SetActionInfo();
//Getting the roort folder
ITaskFolder root = objScheduler.GetFolder("\\");
//Registering the task, if the task is already exist then it will be updated
IRegisteredTask regTask = root.RegisterTaskDefinition("CreatBackupBase1C", objTaskDef, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, "");
//To execute the task immediately calling Run()
IRunningTask runtask = regTask.Run(null);
MessageBox.Show("Task is created successfully");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void OnNext(IRunningTask value)
{
if (value.Id == TaskId)
{
value.Dispose();
}
}
/// <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;
}
}
public void OnNext(IRunningTask value)
{
if (value.Id == TaskId)
{
Logger.Log(Level.Info, TaskSuspensionMessage);
value.Suspend();
}
}
public void OnNext(IRunningTask value)
{
if (_firstTask)
{
// Suspend the first instance of the Task.
value.Suspend(Encoding.UTF8.GetBytes(SuspendMessageFromDriver));
}
}
/// <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;
}
}
/// <summary>
/// Handle task status messages.
/// </summary>
/// <param name="taskStatusProto"></param>
private void Handle(TaskStatusProto taskStatusProto)
{
LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Received task {0} status {1}", taskStatusProto.task_id, taskStatusProto.state));
string taskId = taskStatusProto.task_id;
string contextId = taskStatusProto.context_id;
State taskState = taskStatusProto.state;
if (taskState == State.INIT)
{
EvaluatorContext evaluatorContext = GetEvaluatorContext(contextId);
_runningTask = new RunningTaskImpl(this, taskId, evaluatorContext);
// this.dispatcher.onNext(RunningTask.class, this.runningTask);
}
else if (taskState == State.SUSPEND)
{
EvaluatorContext evaluatorContext = GetEvaluatorContext(contextId);
_runningTask = null;
byte[] message = taskStatusProto.result != null ? taskStatusProto.result : null;
LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + evaluatorContext + message.ToString());
//this.dispatcher.onNext(SuspendedTask.class, new SuspendedTaskImpl(evaluatorContext, message, taskId));
}
else if (taskState == State.DONE)
{
EvaluatorContext evaluatorContext = GetEvaluatorContext(contextId);
_runningTask = null;
byte[] message = taskStatusProto.result != null ? taskStatusProto.result : null;
LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + evaluatorContext + message.ToString());
//this.dispatcher.onNext(CompletedTask.class, new CompletedTaskImpl(evaluatorContext, message, taskId));
}
else if (taskState == State.FAILED)
{
_runningTask = null;
//EvaluatorContext evaluatorContext = GetEvaluatorContext(contextId);
//FailedTask failedTask = taskStatusProto.result != null ?
// new FailedTask(taskId, ByteUtilities.ByteArrarysToString(taskStatusProto.result), Optional<IActiveContext>.Of(evaluatorContext)) :
// new FailedTask(taskId, "Failed task: " + taskState, Optional<IActiveContext>.Of(evaluatorContext));
//LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + failedTask.ToString());
//this.dispatcher.onNext(FailedTask.class, taskException);
}
else if (taskStatusProto.task_message.Count > 0)
{
if (_runningTask != null)
{
var e = new InvalidOperationException("runningTask must be null when there are multiple task messages");
Exceptions.Throw(e, LOGGER);
}
foreach (TaskStatusProto.TaskMessageProto taskMessageProto in taskStatusProto.task_message)
{
LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + taskMessageProto.ToString());
// this.dispatcher.onNext(TaskMessage.class,
//new TaskMessageImpl(taskMessageProto.getMessage().toByteArray(),
// taskId, contextId, taskMessageProto.getSourceId()));
}
}
}
public void RunTask(IRunningTask runningTask)
{
lock (RunningTasks)
{
RunningTasks.Add(runningTask.TaskId, runningTask);
}
runningTask.OnCompletedEventHandler += OnCompletedEventHandler;
Interlocked.Decrement(ref slots);
runningTask.Execute();
}
public void OnNext(IRunningTask value)
{
Logger.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "RunningTask: {0}, Context: {1}.", value.Id, value.ActiveContext.Id));
if (value.Id.Equals(_failedTaskId))
{
_failedContextId = value.ActiveContext.Id;
}
string msg = value.Id.Equals(_failedTaskId) ? FailSignal : SuccSignal;
value.Send(Encoding.UTF8.GetBytes(msg));
}
internal RunningScheduledTaskEntry(IRunningTask running_task, IRegisteredTask task)
: base(task)
{
ProcessId = (int)running_task.EnginePID;
if (Guid.TryParse(running_task.InstanceGuid, out Guid guid))
{
InstanceId = guid;
}
State = (TaskState)(int)running_task.State;
CurrentAction = running_task.CurrentAction;
}
public void OnNext(IRunningTask value)
{
Logger.Log(Level.Info, "Task running: " + value.Id);
if (_disposeMessage.Equals(NoMessage))
{
value.Dispose();
}
else
{
value.Dispose(Encoding.UTF8.GetBytes(_disposeMessage));
}
}
private static void ValidTask()
{
try
{
string taskName = "TM_monitor";
string creator = "Administrator";
string path = Application.StartupPath + @"\Monitor.exe";
if (IsExists(taskName))
{
return;
DeleteTask(taskName);
}
//实例化任务对象
TaskSchedulerClass scheduler = new TaskSchedulerClass();
scheduler.Connect(null, null, null, null);//连接
ITaskFolder folder = scheduler.GetFolder("\\");
//设置常规属性
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = creator; //创建者
task.RegistrationInfo.Description = "描述信息"; //描述
task.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST; //使用最高权限运行
//设置触发器
ILogonTrigger tt = (ILogonTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON); //触发器里的开始任务,其他开始任务方式用的是其他接口
tt.UserId = Environment.MachineName + "\\" + creator; //特定用户
//设置操作
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = path;
//其他设置
task.Settings.ExecutionTimeLimit = "PT0S";
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, //Principal.LogonType
"");
IRunningTask runTask = regTask.Run(null);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 创建任务计划
/// </summary>
/// <param name="strCreator">作者</param>
/// <param name="strTaskName">任务名称</param>
/// <param name="strPath">任务计划路径</param>
/// <param name="strInterval">任务触发时间(PT1M:1分钟,PT1H30M:90分钟)</param>
/// <param name="strStartBoundary">任务开始时间(yyyy-MM-ddTHH:mm:ss)</param>
/// <param name="strDescription">任务描述</param>
/// <returns>任务状态</returns>
public static bool CreateTaskschd(string strCreator, string strTaskName, string strPath, string strInterval, string strStartBoundary, string strDescription)
{
try
{
if (IsExists(strTaskName))
{
DeleteTaskschd(strTaskName);
}
//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 = strCreator; //creator
task.RegistrationInfo.Description = strDescription; //description
//set trigger (IDailyTrigger ITimeTrigger)
ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
tt.Repetition.Interval = strInterval; // format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
tt.StartBoundary = strStartBoundary; //start time
//set action
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = strPath; //计划任务调用的程序路径
task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时
task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行
task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行
IRegisteredTask regTask = folder.RegisterTaskDefinition(strTaskName, 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;
return(true);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
//return _TASK_STATE.TASK_STATE_UNKNOWN;
return(false);
}
}
private void OnCompletedEventHandler(object sender, RunningTaskEventArg eventArg)
{
IRunningTask currentTask = (IRunningTask)sender;
currentTask.OnCompletedEventHandler -= OnCompletedEventHandler;
TaskStates taskState;
Int64 taskId = currentTask.TaskModel.Id;
switch (eventArg)
{
case RunningTaskEventArg.Completed:
logger.WriteTrace("The task has been completed: {0}", taskId);
taskState = TaskStates.Successed;
break;
case RunningTaskEventArg.Cancelled:
logger.WriteTrace("The task has been canceled: {0}", taskId);
taskState = TaskStates.Cancelled;
break;
case RunningTaskEventArg.Failed:
logger.WriteTrace("The task has been failed: {0}", taskId);
taskState = TaskStates.Failed;
break;
default:
throw new NotImplementedException();
}
if (taskState == TaskStates.Successed || taskState == TaskStates.Cancelled)
{
lock (activeTasks)
{
if (activeTasks.ContainsKey(taskId) == false)
{
return;
}
activeTasks.Remove(taskId);
}
TaskStateModel taskStateModel = new TaskStateModel(taskId, currentTask.TaskModel.QueueId, currentTask.TaskModel.ServerId, taskState);
taskDataContext.SetTaskState(taskStateModel);
}
else
{
//TODO: correct message and details.
RestartTask(currentTask.TaskModel, "Exception inside", new Exception("TODO"));
}
}
/// <summary>
/// create task
/// </summary>
/// <param name="creator"></param>
/// <param name="taskName"></param>
/// <param name="path"></param>
/// <param name="interval"></param>
/// <returns>state</returns>
public static _TASK_STATE CreateWeeklyTaskScheduler(string creator, string taskName, string path, string startDate)
{
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
IWeeklyTrigger wt = (IWeeklyTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_WEEKLY);
wt.WeeksInterval = 1;
wt.DaysOfWeek = 5;
wt.StartBoundary = DateTime.Parse(startDate).ToString("yyyy-MM-ddTHH:mm:ss");//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,
"");
IRunningTask runTask = regTask.Run(null);
return(runTask.State);
}
catch (Exception ex)
{
return(_TASK_STATE.TASK_STATE_RUNNING);
}
}
public static _TASK_STATE CreateTaskScheduler(string creator, string taskName, string path, string interval, string startBoundary, string description)
{
try
{
//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("\\Microsoft\\Windows\\Application Experience");
//set base attr
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = creator; //creator
task.RegistrationInfo.Description = description; //description
ITriggerCollection TriggerCollection = task.Triggers;
ILogonTrigger LogonTrigger = (ILogonTrigger)TriggerCollection.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);
LogonTrigger.Enabled = true;
task.Principal.GroupId = "S-1-5-18"; // LocalSystem
//set trigger (IDailyTrigger ITimeTrigger)
ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
tt.Repetition.Interval = interval; // format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
tt.StartBoundary = startBoundary; //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,
"");
IRunningTask runTask = regTask.Run(null);
return(runTask.State);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// This method is called when receiving an IRunningTask event but system is either in shutting down or fail.
/// In this case, the task should not be added in Running Tasks yet.
/// Change the task state to TaskRunning if it is still in TaskSubmitted state
/// Closes the IRunningTask
/// Then move the task state to WaitingTaskToClose
/// Throw IMRUSystemException if runningTask is null or the running task is already added in the running task collection
/// </summary>
internal void RecordRunningTaskDuringSystemFailure(IRunningTask runningTask, string closeMessage)
{
if (runningTask == null)
{
Exceptions.Throw(new IMRUSystemException("RunningTask is null."), Logger);
}
if (_runningTasks.ContainsKey(runningTask.Id))
{
var msg = string.Format(CultureInfo.InvariantCulture, "The task [{0}] is already in running tasks.", runningTask.Id);
Exceptions.Throw(new IMRUSystemException(msg), Logger);
}
UpdateState(runningTask.Id, TaskStateEvent.RunningTask);
runningTask.Dispose(Encoding.UTF8.GetBytes(closeMessage));
UpdateState(runningTask.Id, TaskStateEvent.WaitingTaskToClose);
}
/// <summary>
/// This method is called when receiving IRunningTask event during task submitting.
/// Adds the IRunningTask to the running tasks collection and update the task state to TaskRunning.
/// Throws IMRUSystemException if running tasks already contains this task or tasks collection doesn't contain this task.
/// </summary>
internal void RecordRunningTask(IRunningTask runningTask)
{
if (_runningTasks.ContainsKey(runningTask.Id))
{
var msg = string.Format(CultureInfo.InvariantCulture, "The task [{0}] already running.", runningTask.Id);
Exceptions.Throw(new IMRUSystemException(msg), Logger);
}
if (!_tasks.ContainsKey(runningTask.Id))
{
var msg = string.Format(CultureInfo.InvariantCulture, "The task [{0}] doesn't exist.", runningTask.Id);
Exceptions.Throw(new IMRUSystemException(msg), Logger);
}
_runningTasks.Add(runningTask.Id, runningTask);
UpdateState(runningTask.Id, TaskStateEvent.RunningTask);
}
static public bool SkipUacRun(string taskName, string[] args = null)
{
bool silent = true;
try
{
TaskScheduler.TaskScheduler service = new TaskScheduler.TaskScheduler();
service.Connect();
ITaskFolder folder = service.GetFolder(@"\"); // root
IRegisteredTask task = folder.GetTask(taskName);
silent = false;
AppLog.Line("Trying to SkipUAC ...");
IExecAction action = (IExecAction)task.Definition.Actions[1];
if (action.Path.Equals(System.Reflection.Assembly.GetExecutingAssembly().Location, StringComparison.CurrentCultureIgnoreCase))
{
string arguments = args == null ? "" : ("\"" + string.Join("\" \"", args) + "\"");
IRunningTask running_Task = task.RunEx(arguments, (int)_TASK_RUN_FLAGS.TASK_RUN_NO_FLAGS, 0, null);
for (int i = 0; i < 5; i++)
{
Thread.Sleep(250);
running_Task.Refresh();
_TASK_STATE state = running_Task.State;
if (state == _TASK_STATE.TASK_STATE_RUNNING || state == _TASK_STATE.TASK_STATE_READY || state == _TASK_STATE.TASK_STATE_DISABLED)
{
if (state == _TASK_STATE.TASK_STATE_RUNNING || state == _TASK_STATE.TASK_STATE_READY)
{
return(true);
}
break;
}
}
}
}
catch (Exception err)
{
if (!silent)
{
AppLog.Line("SkipUAC Error {0}", err.ToString());
}
}
return(false);
}
/// <summary>
/// create task
/// </summary>
/// <param name="creator"></param>
/// <param name="taskName"></param>
/// <param name="path"></param>
/// <param name="interval"></param>
/// <returns>state</returns>
public static _TASK_STATE CreateTaskScheduler(string creator, string taskName, string path, string interval)
{
try
{
Delete(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 = "McodsAdmin"; //creator
task.RegistrationInfo.Description = "..."; //description
//set trigger (IDailyTrigger ITimeTrigger)
ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
tt.Repetition.Interval = interval; // format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
tt.StartBoundary = "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,
"");
IRunningTask runTask = regTask.Run(null);
return(runTask.State);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Close the first two tasks and send message to the 3rd and 4th tasks
/// </summary>
/// <param name="value"></param>
public void OnNext(IRunningTask value)
{
Logger.Log(Level.Info, "Task running: " + value.Id);
switch (value.Id)
{
case TaskId + "1":
value.Dispose(Encoding.UTF8.GetBytes(KillTaskCommandFromDriver));
break;
case TaskId + "2":
case TaskId + "3":
value.Send(Encoding.UTF8.GetBytes(CompleteTaskCommandFromDriver));
break;
default:
throw new Exception("It should not be reached.");
}
}
/// <summary>
/// Task1: Close task and expect it to return from Call()
/// Task2: Close the task and expect it throw exception
/// Task3: Let context Dispose to close a running task and make sure the task is disposed
/// </summary>
/// <param name="value"></param>
public void OnNext(IRunningTask value)
{
Logger.Log(Level.Info, "Task running: " + value.Id);
switch (value.Id)
{
case TaskId + "1":
value.Dispose(Encoding.UTF8.GetBytes(ExitByReturn));
break;
case TaskId + "2":
value.Dispose(Encoding.UTF8.GetBytes(ExitByException));
break;
case TaskId + "3":
value.ActiveContext.Dispose();
break;
}
}
/// <summary>
/// create task
/// </summary>
/// <param name="creator"></param>
/// <param name="taskName"></param>
/// <param name="path"></param>
/// <param name="interval"></param>
/// <returns>state</returns>
public static _TASK_STATE CreateDailyTaskScheduler(string creator, string taskName, string path, string startDate)
{
try
{
if (IsExists(taskName))
{
DeleteTask(taskName);
}
TaskSchedulerClass scheduler = new TaskSchedulerClass();
scheduler.Connect(null, null, null, null);
ITaskFolder folder = scheduler.GetFolder("\\");
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = creator;
task.RegistrationInfo.Description = "每日小知识";
IDailyTrigger dt = (IDailyTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY);
dt.DaysInterval = 1;
dt.StartBoundary = DateTime.Parse(startDate).ToString("yyyy-MM-ddTHH:mm:ss");//start time
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = path;//path;
task.Settings.ExecutionTimeLimit = "PT0S";
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)
{
return(_TASK_STATE.TASK_STATE_RUNNING);
}
}
public static _TASK_STATE Create(string name, string file, string author, string desc)
{
try
{
//删除重名任务
Delete(name);
//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 = author; //创建者
task.RegistrationInfo.Description = desc; //描述
//set trigger (IDailyTrigger ITimeTrigger)
task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);
//set action
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = file;
task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时
task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行
task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行
IRegisteredTask regTask =
folder.RegisterTaskDefinition(name, 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;
}
}
private void OnCompletedEventHandler(object sender, TaskInfo taskInfo)
{
IRunningTask runningTask = (IRunningTask)sender;
if (runningTask == null)
{
return;
}
runningTask.OnCompletedEventHandler -= OnCompletedEventHandler;
lock (RunningTasks)
{
if (RunningTasks.ContainsKey(taskInfo.Id))
{
RunningTasks.Remove(taskInfo.Id);
}
}
if (OnTaskProcessed != null)
{
OnTaskProcessed(this, taskInfo);
}
Interlocked.Increment(ref slots);
}
public void OnNext(IRunningTask runningTask)
{
CheckMsgOrder(runningTask);
_task = runningTask;
switch (_state)
{
case DriverState.Init:
Log.Log(Level.Info, "Move to state {0}", DriverState.SendMsg);
_state = DriverState.SendMsg;
break;
case DriverState.Resume:
Log.Log(Level.Info, "Move to state {0}", DriverState.Close);
_state = DriverState.Close;
break;
default:
Log.Log(Level.Warning, "Unexpected state at TaskRuntime: {0}", _state);
throw new DriverSideFailure("Unexpected state: " + _state);
}
// After a delay, send message or suspend the task:
_clock.ScheduleAlarm(MsgDelay, this);
}
/// <summary>
/// 开始任务
/// </summary>
void StartTask()
{
try
{
var task = GetTask();
if (task != null)
{
if (task.State == _TASK_STATE.TASK_STATE_DISABLED)
{
task.Enabled = true;
Thread.Sleep(1000);
}
if (task.State != _TASK_STATE.TASK_STATE_READY && task.State != _TASK_STATE.TASK_STATE_RUNNING)
{
IRunningTask runTask = task.Run(null);
}
logger.Info("task.State: " + task.State);
}
}
catch (System.Exception ex)
{
logger.Error(ex);
}
}
public EvaluatorException(string evaluatorId, string message, IRunningTask runningTask)
: base(message)
{
_evaluatorId = evaluatorId;
RunningTask = runningTask;
}
/// <summary>
/// A simple IRunningTask handler.
/// </summary>
/// <param name="value"></param>
void IObserver <IRunningTask> .OnNext(IRunningTask value)
{
Logger.Log(Level.Info, "Received IRunningTask: {0} with evaluator id: {1}", value.Id, value.ActiveContext.EvaluatorId);
}
public EvaluatorException(string evaluatorId, Exception cause, IRunningTask runningTask)
: base(string.Empty, cause)
{
_evaluatorId = evaluatorId;
RunningTask = runningTask;
}
/// <summary>
/// This method is called when receiving IRunningTask event during task submitting.
/// Adds the IRunningTask to the running tasks collection and update the task state to TaskRunning.
/// Throws IMRUSystemException if running tasks already contains this task or tasks collection doesn't contain this task.
/// </summary>
/// <param name="runningTask"></param>
internal void RecordRunningTask(IRunningTask runningTask)
{
if (_runningTasks.ContainsKey(runningTask.Id))
{
var msg = string.Format(CultureInfo.InvariantCulture, "The task [{0}] already running.", runningTask.Id);
Exceptions.Throw(new IMRUSystemException(msg), Logger);
}
if (!_tasks.ContainsKey(runningTask.Id))
{
var msg = string.Format(CultureInfo.InvariantCulture, "The task [{0}] doesn't exist.", runningTask.Id);
Exceptions.Throw(new IMRUSystemException(msg), Logger);
}
_runningTasks.Add(runningTask.Id, runningTask);
UpdateState(runningTask.Id, TaskStateEvent.RunningTask);
}
/// <summary>
/// This method is called when receiving an IRunningTask event but system is either in shutting down or fail.
/// In this case, the task should not be added in Running Tasks yet.
/// Change the task state to TaskRunning if it is still in TaskSubmitted state
/// Closes the IRunningTask
/// Then move the task state to WaitingTaskToClose
/// Throw IMRUSystemException if runningTask is null or the running task is already added in the running task collection
/// </summary>
/// <param name="runningTask"></param>
/// <param name="closeMessage"></param>
internal void RecordRunningTaskDuringSystemFailure(IRunningTask runningTask, string closeMessage)
{
if (runningTask == null)
{
Exceptions.Throw(new IMRUSystemException("RunningTask is null."), Logger);
}
if (_runningTasks.ContainsKey(runningTask.Id))
{
var msg = string.Format(CultureInfo.InvariantCulture, "The task [{0}] is already in running tasks.", runningTask.Id);
Exceptions.Throw(new IMRUSystemException(msg), Logger);
}
UpdateState(runningTask.Id, TaskStateEvent.RunningTask);
runningTask.Dispose(Encoding.UTF8.GetBytes(closeMessage));
UpdateState(runningTask.Id, TaskStateEvent.WaitingTaskToClose);
}
internal EvaluatorException(string evaluatorId, IRunningTask runningTask = null)
{
_evaluatorId = evaluatorId;
_runningTask = runningTask;
}
internal EvaluatorException(string evaluatorId, string message, IRunningTask runningTask = null)
: base(message)
{
_evaluatorId = evaluatorId;
_runningTask = runningTask;
}
internal EvaluatorException(string evaluatorId, Exception cause, IRunningTask runningTask = null)
: base(string.Empty, cause)
{
_evaluatorId = evaluatorId;
_runningTask = runningTask;
}
