I am looking for a continuous integration software that allows us to define complex build chains (or flows, or what ever they are called atm). This should not be code-base centred, our intention is to automate an amount of steps in chain. And allow us to execute parts of the chain.
For instance: There is a step called "Generate", its input is a VCS (lets say a subversion repo, where it gets the data to work on) and an input parameter, which is set by the user and corresponds to e.g. a level of compression (or can be anything else, like color, speed, taste).
Then there is a step called "Process", it requires the results from "Generate" and processes them further.
Both steps take a very long time to complete, lets say 24 hours each.
The steps should be able to be called independently of each other, so I can manually trigger "Generate" with "level of compression = 5". After it has finished I also can trigger "Process". Since "Process" depends on "Generate" it must also query for "level of compression". Then it should resolve its dependency (namely "Generate") and map whether there is already a cached version of Generate that corresponds to the revision of it combined with level of compression. The complexity here is to resolve the fact that "Generate" already ran with the given parameters, e.g "r234;compression=5" and avoid starting it again with that (reuse the build)
I know there are CI solutions that currently provide some sort of build chaining but they typically look at VCS revisions only and check whether there was a successful step "Generate" with a given revision 234 only. This however falls short since the level of compression or any other input must also be mapped when resolving dependencies since the build result from the same revision with compression 5 can be totally different than a build result with compression of 10.
The chain must reuse previous steps as much as possible since if "Generate" took already 24 hours, starting "Process" should not start the 24 hours of "Generate" again.