public string[] Validate(RegisteredTask[] registeredTasks)
{
return registeredTasks.GroupBy(x => x.Name)
.Where(x => x.Count() > 1)
.Select(x => $"The task \"{x.Key}\" is registered more than once.")
.ToArray();
}
private RegisteredTask register(int id, Type type)
{
RegisteredTask task = new RegisteredTask(id, type);
this.allTasks.Add(task);
return(task);
}
void OnUnregister()
{
if (HasTask)
{
RegisteredTask.Unregister(false);
}
}
public string[] Validate(RegisteredTask[] registeredTasks)
{
var defaultTasks = registeredTasks.Where(x => x.IsDefault).ToArray();
if (defaultTasks.Length > 1)
return new[] {$"Multiple default tasks are specified. Please call \"{nameof(RegisteredTaskConfigurator.AsDefault)}()\" only once."};
return new string[0];
}
public void TaskStarted(RegisteredTask task)
{
_states.Add(new TaskState
{
Task = task,
Result = TaskStateResult.StillRunning,
Runtime = Stopwatch.StartNew()
});
}
private TaskManager()
{
TaskManager.singleton = this;
this.allTasks = new List <RegisteredTask>();
this.taskIdle = this.register(0, typeof(TaskIdle));
this.taskBuild = this.register(1, typeof(TaskConstructBuilding));
}
public string[] Validate(RegisteredTask[] registeredTasks)
{
return registeredTasks.SelectMany(task =>
task.DependsOn
.GroupBy(x => x)
.Where(x => x.Count() > 1)
.Select(x => $"The task \"{task.Name}\" depends on \"{x.Key}\" more than once.")
).ToArray();
}
public string[] Validate(RegisteredTask[] registeredTasks)
{
List<string> result = new List<string>();
foreach (var task in registeredTasks)
{
foreach (var dependency in task.DependsOn)
{
if (registeredTasks.Any(x => x.Name == dependency))
continue;
result.Add($"The task \"{task.Name}\" depends on the task \"{dependency}\" which was not registered.");
}
}
return result.ToArray();
}
public string[] Validate(RegisteredTask[] registeredTasks)
{
var result = new List<string>();
foreach (var registeredTask in registeredTasks)
{
try
{
_taskGraphResolver.Resolve(registeredTask);
}
catch (CircularTaskDependencyDetectedException e)
{
if (!result.Contains(e.Message))
result.Add(e.Message);
}
}
return result.ToArray();
}
internal IEnumerable <RegisteredTask> FindPlugins(string dllFile)
{
var assembly = Assembly.LoadFile(dllFile);
IEnumerable <TaskPluginAttribute> taskPlugins = assembly.GetCustomAttributes <TaskPluginAttribute>();
foreach (TaskPluginAttribute taskPlugin in taskPlugins)
{
Type taskPluginType = taskPlugin.PluginType;
Log.Verbose($"[Plugin Class] {taskPluginType.FullName}");
// Get all public static methods from the task plugin type.
MethodInfo[] methods = taskPluginType.GetMethods(BindingFlags.Static | BindingFlags.Public);
foreach (MethodInfo method in methods)
{
// Gets any task attributes on the method.
IEnumerable <BaseTaskAttribute> taskAttributes = method.GetCustomAttributes <BaseTaskAttribute>(inherit: true);
if (!taskAttributes.Any())
{
continue;
}
// Method signature should match a valid task method.
if (!IsValidPluginMethod(method))
{
Log.Warning($"Method {taskPluginType.FullName}.{method.Name} is decorated with one or more task attributes, but does not have the correct signature, so it will not be considered. A valid task method should be a static or instance method that returns void and accepts a first parameter of type {typeof(ICakeContext).FullName} and an optional second parameter of type {typeof(TaskConfig).FullName}.");
continue;
}
Log.Verbose($"[Plugin Method] {taskPluginType.FullName}.{method.Name}");
// Go through each task attribute and create a RegisteredTask object
foreach (BaseTaskAttribute taskAttribute in taskAttributes)
{
var registeredTask = new RegisteredTask
{
AttributeType = taskAttribute.GetType(),
Method = method,
CiSystem = taskAttribute.CiSystem,
ContinueOnError = taskAttribute.ContinueOnError,
};
string envSuffix = taskAttribute.CiSystem is null ? string.Empty : $"-{taskAttribute.CiSystem}";
string methodDetails = $"{registeredTask.Method.DeclaringType.FullName}.{registeredTask.Method.Name} ({registeredTask.Method.DeclaringType.Assembly.GetName().Name})";
switch (taskAttribute)
{
case PipelineTaskAttribute attr:
registeredTask.CoreTask = attr.PipelineTask;
registeredTask.Name = $"_{attr.PipelineTask}-{method.Name}{envSuffix}";
registeredTask.Description = $"{attr.PipelineTask} task - {methodDetails}";
break;
case BeforePipelineTaskAttribute attr:
registeredTask.CoreTask = attr.PipelineTask;
registeredTask.EventType = TaskEventType.BeforeTask;
registeredTask.Name = $"_Before{attr.PipelineTask}-{method.Name}{envSuffix}";
registeredTask.Description = $"Before {attr.PipelineTask} task - {methodDetails}";
break;
case AfterPipelineTaskAttribute attr:
registeredTask.CoreTask = attr.PipelineTask;
registeredTask.EventType = TaskEventType.AfterTask;
registeredTask.Name = $"_After{attr.PipelineTask}-{method.Name}{envSuffix}";
registeredTask.Description = $"After {attr.PipelineTask} task - {methodDetails}";
break;
case ConfigAttribute attr:
registeredTask.Name = $"_Config-{method.Name}{envSuffix}";
registeredTask.Description = $"Config task - {methodDetails}";
registeredTask.Order = attr.Order;
break;
case TaskAttribute attr:
registeredTask.Name = method.Name;
registeredTask.Description = $"{attr.Description}{envSuffix} - {methodDetails}";
registeredTask.RequiresConfig = attr.RequiresConfig;
break;
}
yield return(registeredTask);
}
}
}
}
