[jira] (MNG-5523) support actual incremental build
[
https://jira.codehaus.org/browse/MNG-5523?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=343998#comment-343998
]
Anders Hammar commented on MNG-5523:
Jason and Igor is working on this in a separate library. It is still not
finalized, but you can read more on his blog:
http://takari.io/2014/03/25/incremental-build.html
> support actual incremental build
>
>
> Key: MNG-5523
> URL: https://jira.codehaus.org/browse/MNG-5523
> Project: Maven 2 & 3
> Issue Type: Improvement
> Components: Bootstrap & Build, Performance
>Reporter: Jigar Joshi
>
> h2. Background:
> We have project structure of around 200 project in the maven tree, every
> single build takes around 13 minute of time (clean, compile, test install,
> deploy)
> With current version of maven {{3.1}}, you can skip clean phase and it will
> do incremental build, which is not bullet proof incremental build actually
> h2. Problem example
> {code}
> --root (module)
> \
> |
> |---foo (jar project)
> |
> |---bar (jar project, it consumes foo as dependency)
> {code}
> before
> {code}
> public class Foo{
> public static void sayHello(){
> System.out.println("hello from foo");
> }
> }
> public class Bar{
> public static void main(String arg[]){
> Foo.sayHello();
> }
> }
> {code}
> I do {{mvn clean install}} from root module, it would go successful, I launch
> the {{main()}} method of {{Bar}} now, it will be succesful
> now I modify {{sayHello()}} to
> {code}
> public static void sayHello(String name){
> System.out.println("hello from foo to " + name);
> }
> {code}
> and I execute {{mvn install}} (incremental build) from root module, it will
> still compile and execute successfully because it takes previously built
> artifact for {{Foo}} at compile phase, now if I attempt to run it in IDE or
> in a packaged build it will fail with
> {code}
> Exception in thread "main" java.lang.NoSuchMethodError:
> {code}
> h2. Proposal:
> - somewhere in pre execution phase, it needs to calculate the modified
> source and artifacts and it should be able to detect all the consumers in
> dependency tree (compile, runtime, test all scopes) and flag all the
> artifacts to treat as modified and it should re do build for those
> - all the maven plugins should support incremental build as well
> - plugin needs to be marked to execute incrementally by adding a {{boolean}}
> parameter to {{AbstractMOJO}} to declare that plugin execution needs to be
> calculated in effective incremental way
> - all plugins which are marked as {{incremental}} needs to take the same
> approach as mentioned in first point
> - also in parallel build when it fans out in multiple threads it should have
> knowledge of what plugins to execute effectively
> It would be totally useful to have this feature corrected
> Some other people who wants this as well
> - http://stackoverflow.com/questions/6281699/maven-incremental-building
> -
> http://stackoverflow.com/questions/8918165/does-maven-support-incremental-builds
> *Also See*
> - http://jira.codehaus.org/browse/MCOMPILER-213
> -
> http://blog.jetbrains.com/teamcity/2012/03/incremental-building-with-maven-and-teamcity/
> Thanks!
> Jigar
--
This message was sent by Atlassian JIRA
(v6.1.6#6162)
[jira] (MNG-5523) support actual incremental build
[
https://jira.codehaus.org/browse/MNG-5523?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Jigar Joshi updated MNG-5523:
-
Issue Type: Improvement (was: Bug)
> support actual incremental build
>
>
> Key: MNG-5523
> URL: https://jira.codehaus.org/browse/MNG-5523
> Project: Maven 2 & 3
> Issue Type: Improvement
> Components: Bootstrap & Build, Performance
>Reporter: Jigar Joshi
>
> h2. Background:
> We have project structure of around 200 project in the maven tree, every
> single build takes around 13 minute of time (clean, compile, test install,
> deploy)
> With current version of maven {{3.1}}, you can skip clean phase and it will
> do incremental build, which is not bullet proof incremental build actually
> h2. Problem example
> {code}
> --root (module)
> \
> |
> |---foo (jar project)
> |
> |---bar (jar project, it consumes foo as dependency)
> {code}
> before
> {code}
> public class Foo{
> public static void sayHello(){
> System.out.println("hello from foo");
> }
> }
> public class Bar{
> public static void main(String arg[]){
> Foo.sayHello();
> }
> }
> {code}
> I do {{mvn clean install}} from root module, it would go successful, I launch
> the {{main()}} method of {{Bar}} now, it will be succesful
> now I modify {{sayHello()}} to
> {code}
> public static void sayHello(String name){
> System.out.println("hello from foo to " + name);
> }
> {code}
> and I execute {{mvn install}} (incremental build) from root module, it will
> still compile and execute successfully because it takes previously built
> artifact for {{Foo}} at compile phase, now if I attempt to run it in IDE or
> in a packaged build it will fail with
> {code}
> Exception in thread "main" java.lang.NoSuchMethodError:
> {code}
> h2. Proposal:
> - somewhere in pre execution phase, it needs to calculate the modified
> source and artifacts and it should be able to detect all the consumers in
> dependency tree (compile, runtime, test all scopes) and flag all the
> artifacts to treat as modified and it should re do build for those
> - all the maven plugins should support incremental build as well
> - plugin needs to be marked to execute incrementally by adding a {{boolean}}
> parameter to {{AbstractMOJO}} to declare that plugin execution needs to be
> calculated in effective incremental way
> - all plugins which are marked as {{incremental}} needs to take the same
> approach as mentioned in first point
> - also in parallel build when it fans out in multiple threads it should have
> knowledge of what plugins to execute effectively
> It would be totally useful to have this feature corrected
> Some other people who wants this as well
> - http://stackoverflow.com/questions/6281699/maven-incremental-building
> -
> http://stackoverflow.com/questions/8918165/does-maven-support-incremental-builds
> *Also See*
> - http://jira.codehaus.org/browse/MCOMPILER-213
> -
> http://blog.jetbrains.com/teamcity/2012/03/incremental-building-with-maven-and-teamcity/
> Thanks!
> Jigar
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] (MNG-5523) support actual incremental build
[
https://jira.codehaus.org/browse/MNG-5523?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Jigar Joshi updated MNG-5523:
-
Description:
h2. Background:
We have project structure of around 200 project in the maven tree, every single
build takes around 13 minute of time (clean, compile, test install, deploy)
With current version of maven {{3.1}}, you can skip clean phase and it will do
incremental build, which is not bullet proof incremental build actually
h2. Problem example
{code}
--root (module)
\
|
|---foo (jar project)
|
|---bar (jar project, it consumes foo as dependency)
{code}
before
{code}
public class Foo{
public static void sayHello(){
System.out.println("hello from foo");
}
}
public class Bar{
public static void main(String arg[]){
Foo.sayHello();
}
}
{code}
I do {{mvn clean install}} from root module, it would go successful, I launch
the {{main()}} method of {{Bar}} now, it will be succesful
now I modify {{sayHello()}} to
{code}
public static void sayHello(String name){
System.out.println("hello from foo to " + name);
}
{code}
and I execute {{mvn install}} (incremental build) from root module, it will
still compile and execute successfully because it takes previously built
artifact for {{Foo}} at compile phase, now if I attempt to run it in IDE or in
a packaged build it will fail with
{code}
Exception in thread "main" java.lang.NoSuchMethodError:
{code}
h2. Proposal:
- somewhere in pre execution phase, it needs to calculate the modified source
and artifacts and it should be able to detect all the consumers in dependency
tree (compile, runtime, test all scopes) and flag all the artifacts to treat as
modified and it should re do build for those
- all the maven plugins should support incremental build as well
- plugin needs to be marked to execute incrementally by adding a {{boolean}}
parameter to {{AbstractMOJO}} to declare that plugin execution needs to be
calculated in effective incremental way
- all plugins which are marked as {{incremental}} needs to take the same
approach as mentioned in first point
- also in parallel build when it fans out in multiple threads it should have
knowledge of what plugins to execute effectively
It would be totally useful to have this feature corrected
Some other people who wants this as well
- http://stackoverflow.com/questions/6281699/maven-incremental-building
-
http://stackoverflow.com/questions/8918165/does-maven-support-incremental-builds
*Also See*
- http://jira.codehaus.org/browse/MCOMPILER-213
-
http://blog.jetbrains.com/teamcity/2012/03/incremental-building-with-maven-and-teamcity/
Thanks!
Jigar
was:
h2. Background:
We have project structure of around 200 project in the maven tree, every single
build takes around 13 minute of time (clean, compile, test install, deploy)
With current version of maven {{3.1}}, you can skip clean phase and it will do
incremental build, which is not bullet proof incremental build actually
h2. Problem example
{code}
--root (module)
\
|
|---foo (jar project)
|
|---bar (jar project, it consumes foo as dependency)
{code}
before
{code}
public class Foo{
public static void sayHello(){
System.out.println("hello from foo");
}
}
public class Bar{
public static void main(String arg[]){
Foo.sayHello();
}
}
{code}
I do {{mvn clean install}} from root module, it would go successful, I launch
the {{main()}} method of {{Bar}} now, it will be succesful
now I modify {{sayHello()}} to
{code}
public static void sayHello(String name){
System.out.println("hello from foo to " + name);
}
{code}
and I execute {{mvn install}} (incremental build) from root module, it will
still compile and execute successfully because it takes previously built
artifact for {{Foo}} at compile phase, now if I attempt to run it in IDE or in
a packaged build it will fail with
{code}
Exception in thread "main" java.lang.NoSuchMethodError:
{code}
h2. Proposal:
- somewhere in pre execution phase, it needs to calculate the modified source
and artifacts and it should be able to detect all the consumers in dependency
tree (compile, runtime, test all scopes) and flag all the artifacts to treat as
modified and it should re do build for those
- all the maven plugins should support incremental build as well
- plugin needs to be marked to execute incrementally by adding a {{boolean}}
parameter to {{AbstractMOJO}} to declare that plugin execution needs to be
calculated in effective incremental way
- all plugins which are marked as {{incremental}} needs to take the same
approach as mentioned in first point
[jira] (MNG-5523) support actual incremental build
Jigar Joshi created MNG-5523:
Summary: support actual incremental build
Key: MNG-5523
URL: https://jira.codehaus.org/browse/MNG-5523
Project: Maven 2 & 3
Issue Type: Bug
Components: Bootstrap & Build, Performance
Reporter: Jigar Joshi
h2. Background:
We have project structure of around 200 project in the maven tree, every single
build takes around 13 minute of time (clean, compile, test install, deploy)
With current version of maven {{3.1}}, you can skip clean phase and it will do
incremental build, which is not bullet proof incremental build actually
h2. Problem example
{code}
--root (module)
\
|
|---foo (jar project)
|
|---bar (jar project, it consumes foo as dependency)
{code}
before
{code}
public class Foo{
public static void sayHello(){
System.out.println("hello from foo");
}
}
public class Bar{
public static void main(String arg[]){
Foo.sayHello();
}
}
{code}
I do {{mvn clean install}} from root module, it would go successful, I launch
the {{main()}} method of {{Bar}} now, it will be succesful
now I modify {{sayHello()}} to
{code}
public static void sayHello(String name){
System.out.println("hello from foo to " + name);
}
{code}
and I execute {{mvn install}} (incremental build) from root module, it will
still compile and execute successfully because it takes previously built
artifact for {{Foo}} at compile phase, now if I attempt to run it in IDE or in
a packaged build it will fail with
{code}
Exception in thread "main" java.lang.NoSuchMethodError:
{code}
h2. Proposal:
- somewhere in pre execution phase, it needs to calculate the modified source
and artifacts and it should be able to detect all the consumers in dependency
tree (compile, runtime, test all scopes) and flag all the artifacts to treat as
modified and it should re do build for those
- all the maven plugins should support incremental build as well
- plugin needs to be marked to execute incrementally by adding a {{boolean}}
parameter to {{AbstractMOJO}} to declare that plugin execution needs to be
calculated in effective incremental way
- all plugins which are marked as {{incremental}} needs to take the same
approach as mentioned in first point
- also in parallel build when it fans out in multiple threads it should have
knowledge of what plugins to execute effectively
It would be totally useful to have this feature corrected
Some other people who wants this as well
- http://stackoverflow.com/questions/6281699/maven-incremental-building
-
http://stackoverflow.com/questions/8918165/does-maven-support-incremental-builds
-
*Also See*
- http://jira.codehaus.org/browse/MCOMPILER-213
-
http://blog.jetbrains.com/teamcity/2012/03/incremental-building-with-maven-and-teamcity/
Thanks!
Jigar
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
