tree f16feecb2c4f0860fda83ef9ba83ca3b099e0d5d
parent b0b8f20267f96c902eee5bab85475ee41645bbe3
author Csaba Ringhofer <csringhofer@cloudera.com> 1571066558 +0200
committer Csaba Ringhofer <csringhofer@cloudera.com> 1571137113 +0000

IMPALA-9008: Serialize Maven invocations to deflake query-event-hook-api

The previous commit for this Jira serialized the compilation of
shaded-deps and ext-data-source to fix flakiness. It looks like
this led to a new similar issue related to the parallel compilation
of ext-data-source and query-event-hook-api.

Similarly to the shaded-deps issue, I try to fix this by adding a
fictional dependency (query-event-hook-api -> yarn-extras) to serialize
the build.

Full Maven dependency graph:
fe -> query-event-hook-api -> yarn-extras -> ext-data-source ->
     shaded-deps-> impala-parent
The ordering of query-event-hook-apit, yarn-extras, ext-data-source,
and shaded-deps are arbitrary.

Change-Id: Ice0dfda5ee0ef60c9c208f05b0952555770fc090
Reviewed-on: http://gerrit.cloudera.org:8080/14423
Reviewed-by: Joe McDonnell <joemcdonnell@cloudera.com>
Reviewed-by: Csaba Ringhofer <csringhofer@cloudera.com>
Tested-by: Csaba Ringhofer <csringhofer@cloudera.com>
