Are Drush and Phing redundant? I've installed JenkinsCI on our dev server to start automating our dev build and test process.   I'm using Jenkins with the Git Plugin and some Drush commands via a shell script.

When researching how to use Jenkins in my Drupal dev workflow, I came across a post about using Phing with Drush and Jenkins. So I looked at Phing and I can't see what it does that cannot be done by using Drush commands via a shell scripts.

I'm trying to decide if it makes sense for me to invest the time in learning how to use Phing.  I'm looking for some clarity as to what benefit I will gain by incorporating Phing vs. Drush commands via Shell script.

So my question is for those who use Phing with Drush and Jenkins: how is it that Drush/Drush-Make and Phing differ?  Why did you decide to start using Phing in your process?

Thanks
The answer is that they are certainly not redundant.  

It's true that one can accomplish the same end result using a  bash script that includes drush commands (at least the building part).  But, if what we are looking to do is to integrate our process into a CI framework like JenkinsCI, then using something like phing (ant or capistrano could be substituted here) is the way to go.

With phing we can break up the build process into distinct segments that can report back to Jenkins in an intelligent way.

So for example.  Say that as part of my build process I use drush to enable two modules, node and shouldfail.  Then the build should fail.  But if all we do is tell JenkinsCI to run the following shell command, JenkinsCI will say that the build PASSED:

drush --quiet --yes @staging en node shouldfail


Clearly that's not right.  However if instead we use ant or phing to define the same process, we can also add some fail logic that Jenkins understands, and therefore fail as it should.  The following phing build script tries to do the same thing as the former command, but fails as we expect it to:

&lt;project name="staging" default="enable modules" description="Jenkins Staging Build"&gt;

    &lt;target name="enable modules"&gt;
      &lt;exec  command="drush --quiet --yes @staging en node shouldfail" error='error' checkreturn="true"&gt;
      &lt;/exec&gt;
      &lt;loadfile  property="en.error" file="error" /&gt;
      &lt;if&gt;
        &lt;contains string="${en.error}" substring="warning" /&gt;
        &lt;then&gt;
          &lt;property name="en.fail" value="Could not enable all modules" /&gt;
        &lt;/then&gt;
      &lt;/if&gt;
      &lt;fail if="en.fail" message="${en.fail}" /&gt;
    &lt;/target&gt;

&lt;/project&gt;


BTW ant and phing are almost identical.  The advantage for PHP developers in using phing is that they can more comfortably extend phing.

As for Drupal development and drush being as good as it is, I don't see too much value in extending phing, and think that running exec tasks would suffice to create a smart build template.

Well, in order to answer my question I ended up investing the time to figure out phing.  It's actually pretty intuitive and it doesn't take too long to figure out.