Task chains

[ruslanmogilevskiy]

Hi,

I was trialing the Cake for a week to port my quite complex build to it and at first glance is looks smooth and cool. Thanks to the contributors for such a thing!

I'm using Cake Frosting to implement my build and after implementing dozen of build tasks I started to struggle with changing the build task chain (what task starts when) and moreover understanding the build chain later on. Say you need to add/remove the tasks in the future when you forgot what the heck is going on in your build. You will need a lot of time for this.

Yes, Cake has IsDependentOn/IsDependeeOf attributes and Cake.Graph plugin but IMO they aren't fixing the root cause of the problem - there is no clear and quick way to manage the tasks chain.

Unfortunately, Cake Frosting is quite closed in terms of extensibility (most of the classes are sealed. Why?) so my fix was an introduction of the task chain paradigm inside the Frosting project with keeping it as abstract as possible with abbility to extend it on the client side.

The sources are available here and the example project is here.

The task chain is enabled with a single line of confuguration code:

return new CakeHost()
    ...
	.UseChainedTaskConfigurator<AppTaskChainProvider>()
	.Run(args);

where you'll specify a task chain provider that's implemented in your build project and returns the tasks that will be executed and it looks like this:

class AppTaskChainProvider : ITaskChainProvider
{
    public TaskChainItem GetChain()
    {
        return Chain
            .Task<Task1>()
            .Group("Do something", _ =>
            {
                 // Reference the task type.
                _.Task<Task2>()
                 // Reference the task by name ([TaskName("Task3: do something")]).
                 .Task("Task3: do something");
            })
        // Task chain inline groups example.
        // .Group("Do something else", _ =>
        // {
        //     _.Task<SomeTask>()
        //      .Group("Internal group", _ =>
        //         {
        //             _.Task<OtherTask>();
        //         })
        //      .Task("Task name");
        // })
            // The last task in the chain which the Default task will be dependent on to execute all the chain.
            .Task<FinalTask>();
    }
}

With the task chain defined in your project, you can quickly manage your tasks (add, remove, comment (disable) specific tasks) and visualize what your build actually does even after some time. The task can be referenced by its type or name.

Also, you can group the tasks (.Group(...)) to visually aggregate them so the tasks after it are executed after all tasks in the group. The sub-groups are supported as well.

You can mix the chain approach with your existing code (with IsDependendOn) so the dependecies from the chain just will be added to your existing dependecies.

The build is executed from the top to bottom sequentially and the Default task will be dependent on the final task or group in your chain.

I'm still testing this approach with my build (25 tasks and growing) but it already saves huge amount of time for me.

I've created a draft PR to quickly identify the changes and gather feedback from the Community and @devlead .