public void SetConfiguration(ITaskConfig config, Dictionary <object, object> properties)
{
_config = new WindowsFeatureTaskConfig();
_config.Description = config.Description;
if (properties.ContainsKey("includeAllSubFeatures"))
{
_config.IncludeAllSubFeatures = bool.Parse(properties["includeAllSubFeatures"].ToString());
}
if (properties.ContainsKey("windows10"))
{
_config.IsWindows10 = bool.Parse(properties["windows10"].ToString());
}
if (properties.ContainsKey("remove"))
{
_config.ShouldRemove = bool.Parse(properties["remove"].ToString());
}
_config.Features = new List <string>();
if (properties.ContainsKey("features") && properties["features"] != null)
{
var features = properties["features"] as List <object>;
if (features != null)
{
foreach (object feature in features)
{
_config.Features.Add(feature.ToString());
}
}
}
}
protected bool SetConfig()
{
if (mConfig == null && mManager != null)
{
mConfig = mManager.CreateConfigInstance();
}
if (mConfig != null)
{
(mConfig as CConfig).Name = textBox_name.Text;
mConfig.SetValue("Name", textBox_name.Text);
mConfig.Desc = textBox_desc.Text;
mConfig.Type = CtrlUtil.GetComboBoxText(comboBox_type);
mConfig.Scheduler = CtrlUtil.GetComboBoxText(comboBox_scheduler);
mConfig.AutoRun = checkBox_autorun.Checked;
mConfig.Enabled = checkBox_enabled.Checked;
mConfig.ClearActions();
foreach (IActionParam config in checkedListBox_action.Items)
{
mConfig.AppendAction(config);
}
return(true);
}
return(false);
}
private static object GetConfigurationFromTaskConfig(ITaskConfig taskConfig)
{
Type configurationType = GetConfigType(taskConfig.TaskType);
MethodInfo method = taskConfig.GetType().GetMethod("GetTaskConfig").MakeGenericMethod(new[] { configurationType });
return(method.Invoke(taskConfig, null));
}
public void SetConfiguration(ITaskConfig config, Dictionary <object, object> properties)
{
_config = new MockTaskConfig();
_config.Description = config.Description;
_config.CustomProperty = properties["customProperty"].ToString();
_config.Config = config.Config;
}
public ITask CreateTask(ITaskConfig taskConfig)
{
var config = taskConfigReader.GetTaskConfig(taskConfig);
return(container.Resolve(
taskConfig.TaskType,
new TypedParameter(typeof(string), taskConfig.TaskId),
new TypedParameter(config.GetType(), config)) as ITask);
}
public ITask CreateTask(ITaskConfig config, ITaskType type)
{
if (config == null || !config.Enabled)
{
return(null);
}
lock (mTasks.SyncRoot)
{
CTask task = mTasks[config.Name] as CTask;
if (task == null)
{
if (type == null)
{
type = mSystemContext.TaskTypeManager.GetConfig(config.Type);
}
if (type != null && type.Enabled && !type.TaskClass.Equals(""))
{
if (!type.FileName.Equals(""))
{
task = CommonUtil.CreateInstance(SystemContext, type.FileName, type.TaskClass) as CTask;
}
else
{
task = CommonUtil.CreateInstance(type.TaskClass) as CTask;
}
}
if (task != null)
{
if (task.Init(this, config, type))
{
task.OnTaskStateChanged += new TaskStateChanged(DoTaskStateChanged);
//task.OnBeforeTask += new TaskEvent(DoBeforeTask);
//task.OnAfterTask += new TaskEvent(DoAfterTask);
mTasks.Add(task.Name, task);
task.RefreshState();
}
else
{
return(null);
}
}
}
else
{
task.Config = config;
}
return(task);
}
}
public bool ConfigTask(string name, ITaskConfig config)
{
ITask task = GetTask(name);
if (task != null)
{
task.Config = config;
return(true);
}
return(false);
}
public ITask CreateTask(ITaskConfig config)
{
if (config != null)
{
ITaskType type = mSystemContext.TaskTypeManager.GetConfig(config.Type);
return(CreateTask(config, type));
}
else
{
return(null);
}
}
public static string GetTaskInfo(this ITaskConfig taskConfig)
{
var taskInfo = taskConfig.TaskId ?? string.Empty;
if (!string.IsNullOrEmpty(taskConfig.Description))
{
taskInfo += ": " + taskConfig.Description;
}
taskInfo += " [" + taskConfig.TaskType + "]";
return(taskInfo.TrimStart());
}
public ITask CreateTask(string name)
{
ITaskConfig config = mSystemContext.TaskConfigManager.GetConfig(name) as ITaskConfig;
if (config != null)
{
return(CreateTask(config));
}
else
{
return(null);
}
}
public void ShowAddDialog(ITaskType type)
{
Text = "新增任务模块";
mIsOk = false;
mManager = type.SystemContext.TaskConfigManager;
mType = type;
mConfig = null;
InitTypeList(mManager.SystemContext);
InitSchedulerList(mManager.SystemContext);
InitActionList(mManager.SystemContext);
if (InitDialog())
{
ShowDialog();
}
}
public TaskResult RunTask(string taskId)
{
try
{
logger.InfoFormat("Running task: '{0}'", taskId);
ITaskConfig taskConfig = predefinedTasksConfig.GetTaskConfig(taskId);
return(taskFactory.CreateTask(taskConfig).Run());
}
catch (Exception ex)
{
var message = string.Format("Running task '{0}' failed.", taskId);
logger.Info(message, ex);
return(TaskResult.Failed(message));
}
}
public override void ShowEditDialog(IConfig config)
{
Text = "编辑任务模块 - [" + config.Name + "]";
mIsOk = false;
mManager = null;
mType = null;
mConfig = config as ITaskConfig;
if (config.Verify(ACOpts.Manager_Modify, false))
{
InitTypeList(config.SystemContext);
InitSchedulerList(config.SystemContext);
InitActionList(config.SystemContext);
if (InitDialog())
{
ShowDialog();
}
}
}
public void SetConfiguration(ITaskConfig config, Dictionary <object, object> properties)
{
_config = new PowershellTaskConfig();
_config.Description = config.Description;
_config.Commands = new List <string>();
if (properties.ContainsKey("commands") && properties["commands"] != null)
{
var commands = properties["commands"] as List <object>;
if (commands != null)
{
foreach (object command in commands)
{
_config.Commands.Add(command.ToString());
}
}
}
}
public CTask(ITaskManager manager, ITaskConfig config, ITaskType type)
{
Init(manager, config, type);
}
public bool Init(ITaskManager manager, ITaskConfig config, ITaskType type)
{
mConfig = config;
mManager = manager;
mType = type;
if (!IsInit && Verify(ACOpts.Exec_Init))
{
if (mManager.SystemContext.MonitorSystem.IsLocal)
{
if (InitTask())
{
State = TaskState.Init;
Config = mConfig;
if (!IsActive && mConfig.AutoRun)
{
this.Start();
}
return(true);
}
}
else if (mManager.SystemContext.RemoteManageClient != null)
{
SystemContext.RemoteManageClient.OnConnected -= new ClientConnectEvent(DoConnected);
SystemContext.RemoteManageClient.OnDisconnected -= new ClientConnectEvent(DoDisconnected);
SystemContext.RemoteManageClient.OnReceiveData -= new ClientReceiveEvent(DoReceiveData);
SystemContext.RemoteManageClient.OnConnected += new ClientConnectEvent(DoConnected);
SystemContext.RemoteManageClient.OnDisconnected += new ClientConnectEvent(DoDisconnected);
SystemContext.RemoteManageClient.OnReceiveData += new ClientReceiveEvent(DoReceiveData);
IRemoteSystem rs = mManager.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
StringBuilder sb = new StringBuilder(mManager.SystemContext.RequestHeadInfo);
ISchedulerConfig sc = mManager.SystemContext.SchedulerConfigManager.GetConfig(mConfig.Scheduler);
if (sc != null)
{
ISchedulerType st = mManager.SystemContext.SchedulerTypeManager.GetConfig(sc.Type);
if (st != null)
{
sb.Append(sc.Name + "<Scheduler>");
sb.Append("InitConfig<Command>");
sb.Append(st.ToXml() + "<Type>");
sb.Append(sc.ToXml() + "<Config><CommandSegment>");
}
}
IActionConfig ac;
IActionParam[] apList = mConfig.GetActionList();
if (apList != null)
{
foreach (IActionParam pc in apList)
{
ac = mManager.SystemContext.ActionConfigManager.GetConfig(pc.Name);
if (ac != null)
{
IActionType at = mManager.SystemContext.ActionTypeManager.GetConfig(ac.Type);
if (at != null)
{
sb.Append(ac.Name + "<Action>");
sb.Append("Init;Start<Command>");
sb.Append(at.ToXml() + "<Type>");
sb.Append(ac.ToXml() + "<Config><CommandSegment>");
}
}
}
}
sb.Append(Name + "<Task>");
sb.Append("Init<Command>");
sb.Append(mType.ToXml() + "<Type>");
sb.Append(mConfig.ToXml() + "<Config>");
return(mManager.SystemContext.RemoteManageClient.WaitReliableSend(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
}
return(false);
}
else
{
return(true);
}
}
public object GetTaskConfig(ITaskConfig taskConfig)
{
return(GetConfigurationFromTaskConfig(taskConfig));
}
protected override TaskResult DoTask()
{
ITaskConfig taskConfig = tasksConfig.GetTaskConfig(config.TaskId);
return(taskFactory.CreateTask(taskConfig).Run());
}
public void SetConfiguration(ITaskConfig config, Dictionary <object, object> properties)
{
_config = new PowershellFileTaskConfig();
_config.Description = config.Description;
_config.Uri = properties["uri"].ToString();
}
public static void AddRemoteConfig(IMonitorSystemContext context, string name, string data, bool saveConfig)
{
IConfig config = null;
if (data.StartsWith("<Monitor>"))
{
config = context.MonitorConfigManager.GetConfig(name);
if (config == null)
{
IMonitorConfig monitorConfig = context.MonitorConfigManager.BuildConfigFromXml(data) as IMonitorConfig;
if (monitorConfig != null)
{
context.MonitorConfigManager.Append(monitorConfig, saveConfig);
}
}
}
else if (data.StartsWith("<MonitorType>"))
{
config = context.MonitorTypeManager.GetConfig(name);
if (config == null)
{
IMonitorType monitorType = context.MonitorTypeManager.BuildConfigFromXml(data) as IMonitorType;
if (monitorType != null)
{
context.MonitorTypeManager.Append(monitorType, saveConfig);
}
}
}
else if (data.StartsWith("<VideoSource>"))
{
config = context.VideoSourceConfigManager.GetConfig(name);
if (config == null)
{
IVideoSourceConfig vsConfig = context.VideoSourceConfigManager.BuildConfigFromXml(data) as IVideoSourceConfig;
if (vsConfig != null)
{
context.VideoSourceConfigManager.Append(vsConfig, saveConfig);
}
}
}
else if (data.StartsWith("<VideoSourceType>"))
{
config = context.VideoSourceTypeManager.GetConfig(name);
if (config == null)
{
IVideoSourceType vsType = context.VideoSourceTypeManager.BuildConfigFromXml(data) as IVideoSourceType;
if (vsType != null)
{
context.VideoSourceTypeManager.Append(vsType, saveConfig);
}
}
}
else if (data.StartsWith("<Action>"))
{
config = context.ActionConfigManager.GetConfig(name);
if (config == null)
{
IActionConfig actionConfig = context.ActionConfigManager.BuildConfigFromXml(data) as IActionConfig;
if (actionConfig != null)
{
context.ActionConfigManager.Append(actionConfig, saveConfig);
}
}
}
else if (data.StartsWith("<ActionType>"))
{
config = context.ActionTypeManager.GetConfig(name);
if (config == null)
{
IActionType actionType = context.ActionTypeManager.BuildConfigFromXml(data) as IActionType;
if (actionType != null)
{
context.ActionTypeManager.Append(actionType, saveConfig);
}
}
}
else if (data.StartsWith("<Scheduler>"))
{
config = context.SchedulerConfigManager.GetConfig(name);
if (config == null)
{
ISchedulerConfig schedulerConfig = context.SchedulerConfigManager.BuildConfigFromXml(data) as ISchedulerConfig;
if (schedulerConfig != null)
{
context.SchedulerConfigManager.Append(schedulerConfig, saveConfig);
}
}
}
else if (data.StartsWith("<SchedulerType>"))
{
config = context.SchedulerTypeManager.GetConfig(name);
if (config == null)
{
ISchedulerType schedulerType = context.SchedulerTypeManager.BuildConfigFromXml(data) as ISchedulerType;
if (schedulerType != null)
{
context.SchedulerTypeManager.Append(schedulerType, saveConfig);
}
}
}
else if (data.StartsWith("<Task>"))
{
config = context.TaskConfigManager.GetConfig(name);
if (config == null)
{
ITaskConfig taskConfig = context.TaskConfigManager.BuildConfigFromXml(data) as ITaskConfig;
if (taskConfig != null)
{
context.TaskConfigManager.Append(taskConfig, saveConfig);
}
}
}
else if (data.StartsWith("<TaskType>"))
{
config = context.TaskTypeManager.GetConfig(name);
if (config == null)
{
ITaskType taskType = context.TaskTypeManager.BuildConfigFromXml(data) as ITaskType;
if (taskType != null)
{
context.TaskTypeManager.Append(taskType, saveConfig);
}
}
}
else if (data.StartsWith("<RemoteSystem>"))
{
config = context.RemoteSystemConfigManager.GetConfig(name);
if (config == null)
{
IRemoteSystemConfig rsConfig = context.RemoteSystemConfigManager.BuildConfigFromXml(data) as IRemoteSystemConfig;
if (rsConfig != null)
{
context.RemoteSystemConfigManager.Append(rsConfig, saveConfig);
}
}
}
else if (data.StartsWith("<Role>"))
{
config = context.RoleConfigManager.GetConfig(name);
if (config == null)
{
IRoleConfig roleConfig = context.RoleConfigManager.BuildConfigFromXml(data) as IRoleConfig;
if (roleConfig != null)
{
context.RoleConfigManager.Append(roleConfig, saveConfig);
}
}
}
else if (data.StartsWith("<User>"))
{
config = context.UserConfigManager.GetConfig(name);
if (config == null)
{
IUserConfig userConfig = context.UserConfigManager.BuildConfigFromXml(data) as IUserConfig;
if (userConfig != null)
{
context.UserConfigManager.Append(userConfig, saveConfig);
}
}
}
}
public void SetConfiguration(ITaskConfig config, Dictionary <object, object> properties)
{
_config = new OctopusTentacleTaskConfig();
_config.Description = config.Description;
// Guards: role, environment, apikey, server, thumbprint, tentacleName are all required
Guard(properties, "role");
Guard(properties, "environment");
Guard(properties, "apikey");
Guard(properties, "octopusServer");
Guard(properties, "thumbprint");
Guard(properties, "tentacleName");
if (properties.ContainsKey("apikey"))
{
_config.ApiKey = properties["apikey"].ToString();
}
if (properties.ContainsKey("environment"))
{
_config.Environment = properties["environment"].ToString();
}
if (properties.ContainsKey("installDirectory"))
{
_config.TentacleExePath = properties["installDirectory"].ToString();
}
if (properties.ContainsKey("octopusServer"))
{
_config.OctopusServer = properties["octopusServer"].ToString();
}
if (properties.ContainsKey("role"))
{
_config.Role = properties["role"].ToString();
}
if (properties.ContainsKey("thumbprint"))
{
_config.Thumbprint = properties["thumbprint"].ToString();
}
if (properties.ContainsKey("certText"))
{
_config.CertText = properties["certText"].ToString();
}
if (properties.ContainsKey("port"))
{
_config.Port = properties["port"].ToString();
}
if (properties.ContainsKey("homeDir"))
{
_config.HomeDirectory = properties["homeDir"].ToString();
}
if (properties.ContainsKey("appDir"))
{
_config.AppDirectory = properties["appDir"].ToString();
}
if (properties.ContainsKey("tentacleName"))
{
_config.TentacleName = properties["tentacleName"].ToString();
}
if (properties.ContainsKey("exePath"))
{
_config.TentacleName = properties["exePath"].ToString();
}
}
public void SetConfiguration(ITaskConfig config, Dictionary <object, object> properties)
{
Config = config;
}
