Discussion:
tycho - the future
(too old to reply)
Alexandre Sauvé
2008-08-19 17:51:04 UTC
Permalink
Hi,

My company has been using Maven 1 for a couple of years now and we are
looking to make the transition over to the Maven 2 world (waiting for the
best opportunity)! The UI for most of our applications are RCP based. The
build process for the UI is using the PDE and is completely autonomous from
our middle tier build with Maven. We are hoping that with the transition to
Maven 2 there would be some new functionality to allow for RCP/OSGi
development. Unfortunately we have found that we may not have waited long
enough! There have been several options that we have looked at to obtain
bridge Maven and our Eclipse Development:

- *Building Eclipse Plugins with Maven 2 (
http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html
)* In this articles the authors describe in detail how they integrated
Maven2 and Eclipse. One aspect of their approach that I did like was how
they made use of the manifest file to define the dependencies for the
project (similar to how Eclipse works); however they need to use the
'Required-Bundle' tags rather than the improved 'Import-Packages'. Though
well documented this approach wasn't favoured as it did not offer the Mojos
re-built in a repo (they just offer the code for the Mojos but they don't
make their Mojos available) and the article was written in 2006. The
company, Princeton software, was bought by IBM so it is hard to get a hold
of the developers for the project.
- *CodeHaus Maven PDE plugin (http://mojo.codehaus.org/pde-maven-plugin)*
This Mojo triggers the PDE build from Maven. Though this approach would be
fairly straight forward in that the regular PDE mechanism can be used for
building the RCP application there are several drawbacks we see related to
the build occuring in 2 seperate build technologies:
PDE doesn't offer any way to easily integrate Maven 2 report tooling into
its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more Ant based
build cycle)
- *Felix Bundle Plugin for Maven (
http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)* This Mojo is
based on the BND tooling. In this approach all the dependencies are
specified in the POM and manifest is generated during the package lifecycle
in Maven. There are specific commands to provide the 'Export-Package',
'Private-Package', etc. However the BND tooling will analyze the byte code
to determine some information such as the 'Import-Packages'. Though this
tooling works well for generating OSGi bundles it does not leverage the
tooling available in Eclipse. Once you have your plugin working with its
dependencies in Eclipse you then need to rework your POM to ensure that the
manifest that is generated is equivalent to that which you now have in
Eclipse. This is not always a trivial process. Given that limitation this
is the process that is favoured at the moment. Some pros about this
methodology:
+ What is nice about this approach is that everything is done in Maven
allowing you to now hook all the Maven reporting plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that your
bundles cannot be of the format of a jar within the bundle - they have to be
more like regular jars to be used by Maven)
+ Generate target platform in Maven

However after reading the article 'Jason Van Zyl Discusses Sonatype, The
Eclipse Foundation and Maven' (
http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven) we believe
that Tycho seems to be the up and coming solution to bridging the world of
OSGi and Maven. So I have done some research into Tycho and have some
questions:

- At the beginning of the Tycho development it was a set of plugins to
provide building with the PDE compiler (as it understands the whole OSGi
dependency/class loading issues), 'osgi-bundle' lifecycle, generation of
POM, etc. Now it seems to have morphed into Maven 2.1? Is Tycho and
M2Eclipse the basis of the development for Maven 2.1?
- Will the new version be able to do everything with the manifest that
Maven 2.0 does with the POM? Through the manifest be able to tell what
dependencies are required? What if those dependencies are only through
Import-Packages (with a version to make life easier)? Will the integration
with the p2 enable M2Eclipse to determine which bundles supply a given
package and add the required dependencie between the projects?
- Will the p2 integration be on top of the existing Maven repo or a
seperate repo to get bundles from?
- What is the timeline/gameplan for Tycho development at this point?

So as you can see we are really just starting out down this path. We would
be willing to help with development if we find an area that we can
contribute effectively into the project. However as of right now we just
want a starting point to start getting our projects configured to using
Tycho. Could you point us in the right direction? The ReadMe file in the
release now is the one for the Apache Maven, so it doesn't really help with
the configuration of a project using Tycho. Is it the same configuration as
before? Should we be using a different version (previous version than
0.3.0)?

Thanks, Any help you can give would be appreciated!
Alex
James Ervin
2008-08-19 19:40:27 UTC
Permalink
Alex,
I would love to hear the reply myself. You have outlined the issues with
using Maven for PDE very well. I think the issue is how well do you want to
integrate with the PDE? I know you could easily throw the Maven Classpath
container into a plugin project and the JDT will respect it, the issue is
the PDE tooling. Are packages in the maven cp container allowed to be
exported? What about the runtime classpath entries in the manifest.mf? How
about when self-hosting, are those classes also used? I mean outside of the
build automation issues, you really really don't want to be writing code
without self hosting or PDE tooling.

I know I don't have any answers for your questions, only am expressing
interest in the issue. One thing I will say, building Eclipse plugins from
the UI is easy peasy, trying to get the batch or headless mode build working
is a bit of a nightmare. If Maven could simplify this, this would be a
killer app that would perhaps force alot of Eclipse plugin developers into
Maven.

James
Post by Alexandre Sauvé
Hi,
My company has been using Maven 1 for a couple of years now and we are
looking to make the transition over to the Maven 2 world (waiting for the
best opportunity)! The UI for most of our applications are RCP based. The
build process for the UI is using the PDE and is completely autonomous from
our middle tier build with Maven. We are hoping that with the transition to
Maven 2 there would be some new functionality to allow for RCP/OSGi
development. Unfortunately we have found that we may not have waited long
enough! There have been several options that we have looked at to obtain
- *Building Eclipse Plugins with Maven 2 (
http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html
)* In this articles the authors describe in detail how they integrated
Maven2 and Eclipse. One aspect of their approach that I did like was how
they made use of the manifest file to define the dependencies for the
project (similar to how Eclipse works); however they need to use the
'Required-Bundle' tags rather than the improved 'Import-Packages'. Though
well documented this approach wasn't favoured as it did not offer the Mojos
re-built in a repo (they just offer the code for the Mojos but they don't
make their Mojos available) and the article was written in 2006. The
company, Princeton software, was bought by IBM so it is hard to get a hold
of the developers for the project.
- *CodeHaus Maven PDE plugin (http://mojo.codehaus.org/pde-maven-plugin
)* This Mojo triggers the PDE build from Maven. Though this approach
would be fairly straight forward in that the regular PDE mechanism can be
used for building the RCP application there are several drawbacks we see
PDE doesn't offer any way to easily integrate Maven 2 report tooling
into its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more Ant based
build cycle)
- *Felix Bundle Plugin for Maven (
http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)* This Mojo
is based on the BND tooling. In this approach all the dependencies are
specified in the POM and manifest is generated during the package lifecycle
in Maven. There are specific commands to provide the 'Export-Package',
'Private-Package', etc. However the BND tooling will analyze the byte code
to determine some information such as the 'Import-Packages'. Though this
tooling works well for generating OSGi bundles it does not leverage the
tooling available in Eclipse. Once you have your plugin working with its
dependencies in Eclipse you then need to rework your POM to ensure that the
manifest that is generated is equivalent to that which you now have in
Eclipse. This is not always a trivial process. Given that limitation this
is the process that is favoured at the moment. Some pros about this
+ What is nice about this approach is that everything is done in Maven
allowing you to now hook all the Maven reporting plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that your
bundles cannot be of the format of a jar within the bundle - they have to be
more like regular jars to be used by Maven)
+ Generate target platform in Maven
However after reading the article 'Jason Van Zyl Discusses Sonatype, The
Eclipse Foundation and Maven' (
http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven) we
believe that Tycho seems to be the up and coming solution to bridging the
world of OSGi and Maven. So I have done some research into Tycho and have
- At the beginning of the Tycho development it was a set of plugins to
provide building with the PDE compiler (as it understands the whole OSGi
dependency/class loading issues), 'osgi-bundle' lifecycle, generation of
POM, etc. Now it seems to have morphed into Maven 2.1? Is Tycho and
M2Eclipse the basis of the development for Maven 2.1?
- Will the new version be able to do everything with the manifest that
Maven 2.0 does with the POM? Through the manifest be able to tell what
dependencies are required? What if those dependencies are only through
Import-Packages (with a version to make life easier)? Will the integration
with the p2 enable M2Eclipse to determine which bundles supply a given
package and add the required dependencie between the projects?
- Will the p2 integration be on top of the existing Maven repo or a
seperate repo to get bundles from?
- What is the timeline/gameplan for Tycho development at this point?
So as you can see we are really just starting out down this path. We would
be willing to help with development if we find an area that we can
contribute effectively into the project. However as of right now we just
want a starting point to start getting our projects configured to using
Tycho. Could you point us in the right direction? The ReadMe file in the
release now is the one for the Apache Maven, so it doesn't really help with
the configuration of a project using Tycho. Is it the same configuration as
before? Should we be using a different version (previous version than
0.3.0)?
Thanks, Any help you can give would be appreciated!
Alex
--
James E. Ervin, IV

A human being should be able to change a diaper, plan an invasion, butcher a
hog, conn a ship, design a building, write a sonnet, balance accounts, build
a wall, set a bone, comfort the dying, take orders, give orders, cooperate,
act alone, solve equations, analyze a new problem, pitch manure, program a
computer, cook a tasty meal, fight efficiently, die gallantly.
Specialization is for insects.
-Robert A. Heinlein

Blog: http://iacobus.blogspot.com
Alexandre Sauvé
2008-08-19 19:50:14 UTC
Permalink
I am going to be a bit of a broken record here. I would tend to agree
strongly with James. The workflow that I would like to see come out of the
Tycho/M2Eclipse project is that I start building my plugins in Eclipse. The
M2Eclipse tooling may offer some benefits in adding dependencies from a
repository that are not already in my target platform; however I would
leverage a lot of the PDE tooling to manage dependencies and other OSGi
concerns. I make my necessary modifications to the manifest file and plugin
file. It now works in my Eclipse IDE. *Working in the IDE = it will work
off the command line with Maven!* All other PDE automation solutions
available today require a lot of configuration.

How all this will work is the question of the day... :-)
Post by James Ervin
Alex,
I would love to hear the reply myself. You have outlined the issues with
using Maven for PDE very well. I think the issue is how well do you want to
integrate with the PDE? I know you could easily throw the Maven Classpath
container into a plugin project and the JDT will respect it, the issue is
the PDE tooling. Are packages in the maven cp container allowed to be
exported? What about the runtime classpath entries in the manifest.mf? How
about when self-hosting, are those classes also used? I mean outside of the
build automation issues, you really really don't want to be writing code
without self hosting or PDE tooling.
I know I don't have any answers for your questions, only am expressing
interest in the issue. One thing I will say, building Eclipse plugins from
the UI is easy peasy, trying to get the batch or headless mode build working
is a bit of a nightmare. If Maven could simplify this, this would be a
killer app that would perhaps force alot of Eclipse plugin developers into
Maven.
James
Post by Alexandre Sauvé
Hi,
My company has been using Maven 1 for a couple of years now and we are
looking to make the transition over to the Maven 2 world (waiting for the
best opportunity)! The UI for most of our applications are RCP based. The
build process for the UI is using the PDE and is completely autonomous from
our middle tier build with Maven. We are hoping that with the transition to
Maven 2 there would be some new functionality to allow for RCP/OSGi
development. Unfortunately we have found that we may not have waited long
enough! There have been several options that we have looked at to obtain
- *Building Eclipse Plugins with Maven 2 (
http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html
)* In this articles the authors describe in detail how they
integrated Maven2 and Eclipse. One aspect of their approach that I did like
was how they made use of the manifest file to define the dependencies for
the project (similar to how Eclipse works); however they need to use the
'Required-Bundle' tags rather than the improved 'Import-Packages'. Though
well documented this approach wasn't favoured as it did not offer the Mojos
re-built in a repo (they just offer the code for the Mojos but they don't
make their Mojos available) and the article was written in 2006. The
company, Princeton software, was bought by IBM so it is hard to get a hold
of the developers for the project.
- *CodeHaus Maven PDE plugin (
http://mojo.codehaus.org/pde-maven-plugin)* This Mojo triggers the
PDE build from Maven. Though this approach would be fairly straight forward
in that the regular PDE mechanism can be used for building the RCP
application there are several drawbacks we see related to the build occuring
PDE doesn't offer any way to easily integrate Maven 2 report tooling
into its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more Ant based
build cycle)
- *Felix Bundle Plugin for Maven (
http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)* This Mojo
is based on the BND tooling. In this approach all the dependencies are
specified in the POM and manifest is generated during the package lifecycle
in Maven. There are specific commands to provide the 'Export-Package',
'Private-Package', etc. However the BND tooling will analyze the byte code
to determine some information such as the 'Import-Packages'. Though this
tooling works well for generating OSGi bundles it does not leverage the
tooling available in Eclipse. Once you have your plugin working with its
dependencies in Eclipse you then need to rework your POM to ensure that the
manifest that is generated is equivalent to that which you now have in
Eclipse. This is not always a trivial process. Given that limitation this
is the process that is favoured at the moment. Some pros about this
+ What is nice about this approach is that everything is done in Maven
allowing you to now hook all the Maven reporting plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that your
bundles cannot be of the format of a jar within the bundle - they have to be
more like regular jars to be used by Maven)
+ Generate target platform in Maven
However after reading the article 'Jason Van Zyl Discusses Sonatype, The
Eclipse Foundation and Maven' (
http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven) we
believe that Tycho seems to be the up and coming solution to bridging the
world of OSGi and Maven. So I have done some research into Tycho and have
- At the beginning of the Tycho development it was a set of plugins to
provide building with the PDE compiler (as it understands the whole OSGi
dependency/class loading issues), 'osgi-bundle' lifecycle, generation of
POM, etc. Now it seems to have morphed into Maven 2.1? Is Tycho and
M2Eclipse the basis of the development for Maven 2.1?
- Will the new version be able to do everything with the manifest that
Maven 2.0 does with the POM? Through the manifest be able to tell what
dependencies are required? What if those dependencies are only through
Import-Packages (with a version to make life easier)? Will the integration
with the p2 enable M2Eclipse to determine which bundles supply a given
package and add the required dependencie between the projects?
- Will the p2 integration be on top of the existing Maven repo or a
seperate repo to get bundles from?
- What is the timeline/gameplan for Tycho development at this point?
So as you can see we are really just starting out down this path. We
would be willing to help with development if we find an area that we can
contribute effectively into the project. However as of right now we just
want a starting point to start getting our projects configured to using
Tycho. Could you point us in the right direction? The ReadMe file in the
release now is the one for the Apache Maven, so it doesn't really help with
the configuration of a project using Tycho. Is it the same configuration as
before? Should we be using a different version (previous version than
0.3.0)?
Thanks, Any help you can give would be appreciated!
Alex
--
James E. Ervin, IV
A human being should be able to change a diaper, plan an invasion, butcher
a hog, conn a ship, design a building, write a sonnet, balance accounts,
build a wall, set a bone, comfort the dying, take orders, give orders,
cooperate, act alone, solve equations, analyze a new problem, pitch manure,
program a computer, cook a tasty meal, fight efficiently, die gallantly.
Specialization is for insects.
-Robert A. Heinlein
Blog: http://iacobus.blogspot.com
Igor Fedorenko
2008-08-20 20:23:34 UTC
Permalink
Post by James Ervin
Alex,
I would love to hear the reply myself. You have outlined the issues
with using Maven for PDE very well. I think the issue is how well do
you want to integrate with the PDE? I know you could easily throw the
Maven Classpath container into a plugin project and the JDT will respect
it, the issue is the PDE tooling. Are packages in the maven cp
container allowed to be exported? What about the runtime classpath
entries in the manifest.mf? How about when self-hosting, are those
classes also used? I mean outside of the build automation issues, you
really really don't want to be writing code without self hosting or PDE
tooling.
Most likely PDE integration will be different for manifest-first and
pom-first projects. For manifest-first, we really want PDE to do its
things and m2e classpath container will only cause problems. For
pom-first projects, we'll have to find a way to synchronize PDE with
pom.xml. I have some ideas how to do this, but no code yet.
Post by James Ervin
I know I don't have any answers for your questions, only am expressing
interest in the issue. One thing I will say, building Eclipse plugins
from the UI is easy peasy, trying to get the batch or headless mode
build working is a bit of a nightmare. If Maven could simplify this,
this would be a killer app that would perhaps force alot of Eclipse
plugin developers into Maven.
James
On Tue, Aug 19, 2008 at 12:51 PM, Alexandre Sauvé
Hi,
My company has been using Maven 1 for a couple of years now and we
are looking to make the transition over to the Maven 2 world
(waiting for the best opportunity)! The UI for most of our
applications are RCP based. The build process for the UI is using
the PDE and is completely autonomous from our middle tier build with
Maven. We are hoping that with the transition to Maven 2 there
would be some new functionality to allow for RCP/OSGi development.
Unfortunately we have found that we may not have waited long
enough! There have been several options that we have looked at to
* *Building Eclipse Plugins with Maven 2
(http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html)*
In this articles the authors describe in detail how they
integrated Maven2 and Eclipse. One aspect of their approach
that I did like was how they made use of the manifest file to
define the dependencies for the project (similar to how
Eclipse works); however they need to use the 'Required-Bundle'
tags rather than the improved 'Import-Packages'. Though well
documented this approach wasn't favoured as it did not offer
the Mojos re-built in a repo (they just offer the code for the
Mojos but they don't make their Mojos available) and the
article was written in 2006. The company, Princeton software,
was bought by IBM so it is hard to get a hold of the
developers for the project.
* *CodeHaus Maven PDE plugin
(http://mojo.codehaus.org/pde-maven-plugin)* This Mojo
triggers the PDE build from Maven. Though this approach would
be fairly straight forward in that the regular PDE mechanism
can be used for building the RCP application there are several
drawbacks we see related to the build occuring in 2 seperate
PDE doesn't offer any way to easily integrate Maven 2 report
tooling into its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more
Ant based build cycle)
* *Felix Bundle Plugin for Maven
(http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)*
This Mojo is based on the BND tooling. In this approach all
the dependencies are specified in the POM and manifest is
generated during the package lifecycle in Maven. There are
specific commands to provide the 'Export-Package',
'Private-Package', etc. However the BND tooling will analyze
the byte code to determine some information such as the
'Import-Packages'. Though this tooling works well for
generating OSGi bundles it does not leverage the tooling
available in Eclipse. Once you have your plugin working with
its dependencies in Eclipse you then need to rework your POM
to ensure that the manifest that is generated is equivalent to
that which you now have in Eclipse. This is not always a
trivial process. Given that limitation this is the process
that is favoured at the moment. Some pros about this
+ What is nice about this approach is that everything is done
in Maven allowing you to now hook all the Maven reporting
plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that
your bundles cannot be of the format of a jar within the
bundle - they have to be more like regular jars to be used by
Maven)
+ Generate target platform in Maven
However after reading the article 'Jason Van Zyl Discusses Sonatype,
The Eclipse Foundation and Maven'
(http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven)
we believe that Tycho seems to be the up and coming solution to
bridging the world of OSGi and Maven. So I have done some research
* At the beginning of the Tycho development it was a set of
plugins to provide building with the PDE compiler (as it
understands the whole OSGi dependency/class loading issues),
'osgi-bundle' lifecycle, generation of POM, etc. Now it seems
to have morphed into Maven 2.1? Is Tycho and M2Eclipse the
basis of the development for Maven 2.1?
* Will the new version be able to do everything with the
manifest that Maven 2.0 does with the POM? Through the
manifest be able to tell what dependencies are required? What
if those dependencies are only through Import-Packages (with a
version to make life easier)? Will the integration with the
p2 enable M2Eclipse to determine which bundles supply a given
package and add the required dependencie between the projects?
* Will the p2 integration be on top of the existing Maven repo
or a seperate repo to get bundles from?
* What is the timeline/gameplan for Tycho development at this point?
So as you can see we are really just starting out down this path.
We would be willing to help with development if we find an area that
we can contribute effectively into the project. However as of right
now we just want a starting point to start getting our projects
configured to using Tycho. Could you point us in the right
direction? The ReadMe file in the release now is the one for the
Apache Maven, so it doesn't really help with the configuration of a
project using Tycho. Is it the same configuration as before?
Should we be using a different version (previous version than 0.3.0)?
Thanks, Any help you can give would be appreciated!
Alex
--
James E. Ervin, IV
A human being should be able to change a diaper, plan an invasion,
butcher a hog, conn a ship, design a building, write a sonnet, balance
accounts, build a wall, set a bone, comfort the dying, take orders, give
orders, cooperate, act alone, solve equations, analyze a new problem,
pitch manure, program a computer, cook a tasty meal, fight efficiently,
die gallantly. Specialization is for insects.
-Robert A. Heinlein
Blog: http://iacobus.blogspot.com
Igor Fedorenko
2008-08-20 19:44:32 UTC
Permalink
Hello, Alexandre and others.

First of all, I have to apologize for keeping Tycho development plans
and progress to myself. I would like to thank you for bringing this up
and will try to both explain our grand vision and what we already have
or will have implemented in the near future.

The big picture. Ultimately, we want tycho to be one-stop solution for
doing Eclipse and OSGi development with Maven 2 (actually, 3, more on
this later). We believe there are two distinct development workflows,
when developer explicitly creates and maintains OSGi manifest and other
Eclipse/OSGi metadata (we call it "manifest-first") and when OSGi
metadata is generated by the build based on information available from
pom.xml ("pom-first", naturally). We plan to support both development
workflows.

In manifest-first mode, tycho will use Eclipse/OSGi metadata and OSGi
rules to calculate project dependencies dynamically, at build time. It
will support all attributes supported by Eclipse OSGi resolver
(Require-Bundle, Import-Package, Eclipse-GenericRequire, etc). It will
use proper classpath access rules during compilation. It will support
all projects supported by PDE and will use PDE/JDT project metadata
where applicable. One important design goal is to make sure there is no
duplication of metadata between pom.xml files and Eclipse/OSGi config
files. In fact, tycho will support "pom-less" projects, where all
required build metadata is derived from Eclipse/OSGi config files.

In pom-first mode current plan is to provide similar set of features as
in felix/bnd plugin, although I do not know if we'll be able to share
any of the code. Additionally, Tycho will support Eclipse-friendlier
Require-Bundle and will provide better support for developing multiple
related OSGi bundles (I have not checked recently, so felix/bnd may
already support these).

In both modes tycho will support remote repositories both as source and
sink for artifacts. We plan to support maven repositories, p2 and update
sites, although level of support will likely vary. There will also be
integration between m2e, tycho and pde to make the three work nicely
together.

So these are the plans... Disclaimer: plans do change! ;-)

Now to what tycho is already able to do. Our first goal was to enable
m2e continues build, so we started with manifest-first mode and I
believe covered most of manifest-first features described above. Tycho
already uses Eclipse/OSGi metadata to resolve project dependencies by
OSGi rules and injects these dependencies into maven project model
dynamically, at build time. It supports bundle, fragment, feature and
update site projects (shame on me, but no RCP application yet). It knows
how to run junit test plugins using OSGi runtime. Two big features that
are still missing, are support for pom-less projects and work with
artifact repositories, although there is prototype of target platform
materialization from p2 repository already. There is also some
rudimentary implementation of pom-first mode, but its usability outside
of m2e build context is probably limited. Many smaller features are
still missing and I am certain there are quite a few bugs too, but I
think overall tycho code is in reasonably good shape already.

Few words about relationship between maven and tycho. Tycho is not
morphing into maven, but it provides maven extensions and plugins that
enable maven to work with Eclipse/OSGi projects. Some of tycho
functionality, especially OSGi dependency injection, relies on maven
features only available in maven 3.0 which was very recently renamed
from 2.1. Since there is no maven 3.0 release yet, current tycho
distribution includes complete copy of maven 3.0-SNAPSHOT.


As for contributing to the project... well, this would be really awesome
. I think the best way to start is to try tycho and see what is missing
to support your projects and development workflow. Then we can work
together to implement missing features, fix bugs, etc. I have simple
demo that shows how to use tycho to build set of simple projects and
some user-level documentation. I will try to make this available later
today. I will also provide tycho dev env setup steps, so you can start
looking at the code if you want to. And tycho distribution is already
available from [1] (looks for the latest .zip file)

I hope it answers your questions, but feel free to ask more, especially
if something is not clear or does not make sense.

--
Regards,
Igor Fedorenko


[1]
http://repository.sonatype.org/service/local/repositories/eclipse-snapshots/content/org/codehaus/tycho/tycho-distribution/0.3.0-SNAPSHOT/
Post by Alexandre Sauvé
Hi,
My company has been using Maven 1 for a couple of years now and we are
looking to make the transition over to the Maven 2 world (waiting for
the best opportunity)! The UI for most of our applications are RCP
based. The build process for the UI is using the PDE and is completely
autonomous from our middle tier build with Maven. We are hoping that
with the transition to Maven 2 there would be some new functionality to
allow for RCP/OSGi development. Unfortunately we have found that we may
not have waited long enough! There have been several options that we
* *Building Eclipse Plugins with Maven 2
(http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html)*
In this articles the authors describe in detail how they
integrated Maven2 and Eclipse. One aspect of their approach that
I did like was how they made use of the manifest file to define
the dependencies for the project (similar to how Eclipse works);
however they need to use the 'Required-Bundle' tags rather than
the improved 'Import-Packages'. Though well documented this
approach wasn't favoured as it did not offer the Mojos re-built in
a repo (they just offer the code for the Mojos but they don't make
their Mojos available) and the article was written in 2006. The
company, Princeton software, was bought by IBM so it is hard to
get a hold of the developers for the project.
* *CodeHaus Maven PDE plugin
(http://mojo.codehaus.org/pde-maven-plugin)* This Mojo triggers
the PDE build from Maven. Though this approach would be fairly
straight forward in that the regular PDE mechanism can be used for
building the RCP application there are several drawbacks we see
PDE doesn't offer any way to easily integrate Maven 2 report
tooling into its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more Ant
based build cycle)
* *Felix Bundle Plugin for Maven
(http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)* This
Mojo is based on the BND tooling. In this approach all the
dependencies are specified in the POM and manifest is generated
during the package lifecycle in Maven. There are specific
commands to provide the 'Export-Package', 'Private-Package', etc.
However the BND tooling will analyze the byte code to determine
some information such as the 'Import-Packages'. Though this
tooling works well for generating OSGi bundles it does not
leverage the tooling available in Eclipse. Once you have your
plugin working with its dependencies in Eclipse you then need to
rework your POM to ensure that the manifest that is generated is
equivalent to that which you now have in Eclipse. This is not
always a trivial process. Given that limitation this is the
process that is favoured at the moment. Some pros about this
+ What is nice about this approach is that everything is done in
Maven allowing you to now hook all the Maven reporting plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that your
bundles cannot be of the format of a jar within the bundle - they
have to be more like regular jars to be used by Maven)
+ Generate target platform in Maven
However after reading the article 'Jason Van Zyl Discusses Sonatype, The
Eclipse Foundation and Maven'
(http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven) we
believe that Tycho seems to be the up and coming solution to bridging
the world of OSGi and Maven. So I have done some research into Tycho
* At the beginning of the Tycho development it was a set of plugins
to provide building with the PDE compiler (as it understands the
whole OSGi dependency/class loading issues), 'osgi-bundle'
lifecycle, generation of POM, etc. Now it seems to have morphed
into Maven 2.1? Is Tycho and M2Eclipse the basis of the
development for Maven 2.1?
* Will the new version be able to do everything with the manifest
that Maven 2.0 does with the POM? Through the manifest be able to
tell what dependencies are required? What if those dependencies
are only through Import-Packages (with a version to make life
easier)? Will the integration with the p2 enable M2Eclipse to
determine which bundles supply a given package and add the
required dependencie between the projects?
* Will the p2 integration be on top of the existing Maven repo or a
seperate repo to get bundles from?
* What is the timeline/gameplan for Tycho development at this point?
So as you can see we are really just starting out down this path. We
would be willing to help with development if we find an area that we can
contribute effectively into the project. However as of right now we
just want a starting point to start getting our projects configured to
using Tycho. Could you point us in the right direction? The ReadMe
file in the release now is the one for the Apache Maven, so it doesn't
really help with the configuration of a project using Tycho. Is it the
same configuration as before? Should we be using a different version
(previous version than 0.3.0)?
Thanks, Any help you can give would be appreciated!
Alex
Alexandre Sauvé
2008-08-20 20:13:16 UTC
Permalink
Igor,

That's great news! I will definitely try Tycho once I get an idea on the
'How'...

For me I am more interested in the 'manifest-first' as I have worked already
with Felix and find that generating the manifest is not exactly the Eclipse
way to go... So that being said it seems that you have most of everything in
place for me to try! I would like some more information on what is
missing/implemented in the artifact repository front. In your email you
mention generating a target platform from a p2 repo, that is terrific! But
how do you configure such a repo or have a p2 implementation fronting an
existing Maven repo. If this work is currently on going how do you guys
work with your artifact as of today? Is your target platform prebuilt and
you point your maven build toward your target platform? Will your example
cover this?

Looking forward to getting my hands dirty.
Alex
Post by Igor Fedorenko
Hello, Alexandre and others.
First of all, I have to apologize for keeping Tycho development plans and
progress to myself. I would like to thank you for bringing this up and will
try to both explain our grand vision and what we already have or will have
implemented in the near future.
The big picture. Ultimately, we want tycho to be one-stop solution for
doing Eclipse and OSGi development with Maven 2 (actually, 3, more on this
later). We believe there are two distinct development workflows, when
developer explicitly creates and maintains OSGi manifest and other
Eclipse/OSGi metadata (we call it "manifest-first") and when OSGi metadata
is generated by the build based on information available from pom.xml
("pom-first", naturally). We plan to support both development workflows.
In manifest-first mode, tycho will use Eclipse/OSGi metadata and OSGi rules
to calculate project dependencies dynamically, at build time. It will
support all attributes supported by Eclipse OSGi resolver (Require-Bundle,
Import-Package, Eclipse-GenericRequire, etc). It will use proper classpath
access rules during compilation. It will support all projects supported by
PDE and will use PDE/JDT project metadata where applicable. One important
design goal is to make sure there is no duplication of metadata between
pom.xml files and Eclipse/OSGi config files. In fact, tycho will support
"pom-less" projects, where all required build metadata is derived from
Eclipse/OSGi config files.
In pom-first mode current plan is to provide similar set of features as in
felix/bnd plugin, although I do not know if we'll be able to share any of
the code. Additionally, Tycho will support Eclipse-friendlier Require-Bundle
and will provide better support for developing multiple related OSGi bundles
(I have not checked recently, so felix/bnd may already support these).
In both modes tycho will support remote repositories both as source and
sink for artifacts. We plan to support maven repositories, p2 and update
sites, although level of support will likely vary. There will also be
integration between m2e, tycho and pde to make the three work nicely
together.
So these are the plans... Disclaimer: plans do change! ;-)
Now to what tycho is already able to do. Our first goal was to enable m2e
continues build, so we started with manifest-first mode and I believe
covered most of manifest-first features described above. Tycho already uses
Eclipse/OSGi metadata to resolve project dependencies by OSGi rules and
injects these dependencies into maven project model dynamically, at build
time. It supports bundle, fragment, feature and update site projects (shame
on me, but no RCP application yet). It knows how to run junit test plugins
using OSGi runtime. Two big features that are still missing, are support for
pom-less projects and work with artifact repositories, although there is
prototype of target platform materialization from p2 repository already.
There is also some rudimentary implementation of pom-first mode, but its
usability outside of m2e build context is probably limited. Many smaller
features are still missing and I am certain there are quite a few bugs too,
but I think overall tycho code is in reasonably good shape already.
Few words about relationship between maven and tycho. Tycho is not morphing
into maven, but it provides maven extensions and plugins that enable maven
to work with Eclipse/OSGi projects. Some of tycho functionality, especially
OSGi dependency injection, relies on maven features only available in maven
3.0 which was very recently renamed from 2.1. Since there is no maven 3.0
release yet, current tycho distribution includes complete copy of maven
3.0-SNAPSHOT.
As for contributing to the project... well, this would be really awesome .
I think the best way to start is to try tycho and see what is missing to
support your projects and development workflow. Then we can work together to
implement missing features, fix bugs, etc. I have simple demo that shows how
to use tycho to build set of simple projects and some user-level
documentation. I will try to make this available later today. I will also
provide tycho dev env setup steps, so you can start looking at the code if
you want to. And tycho distribution is already available from [1] (looks for
the latest .zip file)
I hope it answers your questions, but feel free to ask more, especially if
something is not clear or does not make sense.
--
Regards,
Igor Fedorenko
[1]
http://repository.sonatype.org/service/local/repositories/eclipse-snapshots/content/org/codehaus/tycho/tycho-distribution/0.3.0-SNAPSHOT/
Post by Alexandre Sauvé
Hi,
My company has been using Maven 1 for a couple of years now and we are
looking to make the transition over to the Maven 2 world (waiting for the
best opportunity)! The UI for most of our applications are RCP based. The
build process for the UI is using the PDE and is completely autonomous from
our middle tier build with Maven. We are hoping that with the transition to
Maven 2 there would be some new functionality to allow for RCP/OSGi
development. Unfortunately we have found that we may not have waited long
enough! There have been several options that we have looked at to obtain
* *Building Eclipse Plugins with Maven 2
(
http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html)*<http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html%29*> In this articles the authors describe in detail how they
integrated Maven2 and Eclipse. One aspect of their approach that
I did like was how they made use of the manifest file to define
the dependencies for the project (similar to how Eclipse works);
however they need to use the 'Required-Bundle' tags rather than
the improved 'Import-Packages'. Though well documented this
approach wasn't favoured as it did not offer the Mojos re-built in
a repo (they just offer the code for the Mojos but they don't make
their Mojos available) and the article was written in 2006. The
company, Princeton software, was bought by IBM so it is hard to
get a hold of the developers for the project.
* *CodeHaus Maven PDE plugin
(http://mojo.codehaus.org/pde-maven-plugin)*<http://mojo.codehaus.org/pde-maven-plugin%29*> This Mojo triggers
the PDE build from Maven. Though this approach would be fairly
straight forward in that the regular PDE mechanism can be used for
building the RCP application there are several drawbacks we see
PDE doesn't offer any way to easily integrate Maven 2 report
tooling into its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more Ant
based build cycle)
* *Felix Bundle Plugin for Maven
(http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)*<http://felix.apache.org/site/mavem-bundle-plugin-bnd.html%29*>This
Mojo is based on the BND tooling. In this approach all the
dependencies are specified in the POM and manifest is generated
during the package lifecycle in Maven. There are specific
commands to provide the 'Export-Package', 'Private-Package', etc.
However the BND tooling will analyze the byte code to determine
some information such as the 'Import-Packages'. Though this
tooling works well for generating OSGi bundles it does not
leverage the tooling available in Eclipse. Once you have your
plugin working with its dependencies in Eclipse you then need to
rework your POM to ensure that the manifest that is generated is
equivalent to that which you now have in Eclipse. This is not
always a trivial process. Given that limitation this is the
process that is favoured at the moment. Some pros about this
+ What is nice about this approach is that everything is done in
Maven allowing you to now hook all the Maven reporting plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that your
bundles cannot be of the format of a jar within the bundle - they
have to be more like regular jars to be used by Maven)
+ Generate target platform in Maven
However after reading the article 'Jason Van Zyl Discusses Sonatype, The
Eclipse Foundation and Maven' (
http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven) we
believe that Tycho seems to be the up and coming solution to bridging the
world of OSGi and Maven. So I have done some research into Tycho and have
* At the beginning of the Tycho development it was a set of plugins
to provide building with the PDE compiler (as it understands the
whole OSGi dependency/class loading issues), 'osgi-bundle'
lifecycle, generation of POM, etc. Now it seems to have morphed
into Maven 2.1? Is Tycho and M2Eclipse the basis of the
development for Maven 2.1?
* Will the new version be able to do everything with the manifest
that Maven 2.0 does with the POM? Through the manifest be able to
tell what dependencies are required? What if those dependencies
are only through Import-Packages (with a version to make life
easier)? Will the integration with the p2 enable M2Eclipse to
determine which bundles supply a given package and add the
required dependencie between the projects?
* Will the p2 integration be on top of the existing Maven repo or a
seperate repo to get bundles from?
* What is the timeline/gameplan for Tycho development at this point?
So as you can see we are really just starting out down this path. We
would be willing to help with development if we find an area that we can
contribute effectively into the project. However as of right now we just
want a starting point to start getting our projects configured to using
Tycho. Could you point us in the right direction? The ReadMe file in the
release now is the one for the Apache Maven, so it doesn't really help with
the configuration of a project using Tycho. Is it the same configuration as
before? Should we be using a different version (previous version than
0.3.0)?
Thanks, Any help you can give would be appreciated!
Alex
---------------------------------------------------------------------
http://xircles.codehaus.org/manage_email
Igor Fedorenko
2008-08-21 01:56:06 UTC
Permalink
Post by Alexandre Sauvé
Igor,
That's great news! I will definitely try Tycho once I get an idea on
the 'How'...
Demo script

http://docs.codehaus.org/display/M2ECLIPSE/tycho+technology+demo+script

Some user docs

http://docs.codehaus.org/display/M2ECLIPSE/Tycho+user+docs
Post by Alexandre Sauvé
For me I am more interested in the 'manifest-first' as I have worked
already with Felix and find that generating the manifest is not exactly
the Eclipse way to go... So that being said it seems that you have most
of everything in place for me to try! I would like some more
information on what is missing/implemented in the artifact repository
front. In your email you mention generating a target platform from a p2
repo, that is terrific! But how do you configure such a repo or have a
p2 implementation fronting an existing Maven repo. If this work is
currently on going how do you guys work with your artifact as of today?
Is your target platform prebuilt and you point your maven build toward
your target platform? Will your example cover this?
Yes, example shows how to use existing eclipse installation as build
target platform, and I suggest this is what you use, at least initially,
to make sure other tycho functionality works first.

Artifact repositories support is the least explored area, and the code
that I wrote for p2 support was really meant to prove possibility to run
p2 client inside maven runtime. It is only able to consume artifacts
from existing p2 repositories, but it is not able to generate p2
repository. Also, tycho is not able to deploy build results into maven
artifact repository yet, not in a meaningful way, at least.

So, consider yourself warned, and if you still want to try p2 repo
support, here are few pointers. m2e parent pom [1] has "e34-p2" profile
that defines few extra repositories with p2 layout as well as few
dependencyManagement dependencies that define p2 root installable units
(IUs). When running m2e with e34-p2 profile enabled but without
tycho.targetPlatform parameter, tycho will start p2 client and will
instruct it to download/create/configure eclipse installation with all
p2 IUs mentioned in the profile and all their dependencies. This eclipse
install will be created under generated name in ~/.m2/p2/targets folder
and will be used as build target platform. Also, you almost certainly
want to read some p2 documentation, but [2] is the only place I know.

It is also almost certain that current prototype p2 repository support
will go away in its existing form. I have general dissatisfaction with
the current behaviour, but do not know how to make it better yet.


[1]
http://svn.sonatype.org/m2eclipse/trunk/org.maven.ide.eclipse.parent/pom.xml
[2] http://wiki.eclipse.org/Category:Equinox_p2
Post by Alexandre Sauvé
Looking forward to getting my hands dirty.
Alex
Hello, Alexandre and others.
First of all, I have to apologize for keeping Tycho development
plans and progress to myself. I would like to thank you for bringing
this up and will try to both explain our grand vision and what we
already have or will have implemented in the near future.
The big picture. Ultimately, we want tycho to be one-stop solution
for doing Eclipse and OSGi development with Maven 2 (actually, 3,
more on this later). We believe there are two distinct development
workflows, when developer explicitly creates and maintains OSGi
manifest and other Eclipse/OSGi metadata (we call it
"manifest-first") and when OSGi metadata is generated by the build
based on information available from pom.xml ("pom-first",
naturally). We plan to support both development workflows.
In manifest-first mode, tycho will use Eclipse/OSGi metadata and
OSGi rules to calculate project dependencies dynamically, at build
time. It will support all attributes supported by Eclipse OSGi
resolver (Require-Bundle, Import-Package, Eclipse-GenericRequire,
etc). It will use proper classpath access rules during compilation.
It will support all projects supported by PDE and will use PDE/JDT
project metadata where applicable. One important design goal is to
make sure there is no duplication of metadata between pom.xml files
and Eclipse/OSGi config files. In fact, tycho will support
"pom-less" projects, where all required build metadata is derived
from Eclipse/OSGi config files.
In pom-first mode current plan is to provide similar set of features
as in felix/bnd plugin, although I do not know if we'll be able to
share any of the code. Additionally, Tycho will support
Eclipse-friendlier Require-Bundle and will provide better support
for developing multiple related OSGi bundles (I have not checked
recently, so felix/bnd may already support these).
In both modes tycho will support remote repositories both as source
and sink for artifacts. We plan to support maven repositories, p2
and update sites, although level of support will likely vary. There
will also be integration between m2e, tycho and pde to make the
three work nicely together.
So these are the plans... Disclaimer: plans do change! ;-)
Now to what tycho is already able to do. Our first goal was to
enable m2e continues build, so we started with manifest-first mode
and I believe covered most of manifest-first features described
above. Tycho already uses Eclipse/OSGi metadata to resolve project
dependencies by OSGi rules and injects these dependencies into maven
project model dynamically, at build time. It supports bundle,
fragment, feature and update site projects (shame on me, but no RCP
application yet). It knows how to run junit test plugins using OSGi
runtime. Two big features that are still missing, are support for
pom-less projects and work with artifact repositories, although
there is prototype of target platform materialization from p2
repository already. There is also some rudimentary implementation of
pom-first mode, but its usability outside of m2e build context is
probably limited. Many smaller features are still missing and I am
certain there are quite a few bugs too, but I think overall tycho
code is in reasonably good shape already.
Few words about relationship between maven and tycho. Tycho is not
morphing into maven, but it provides maven extensions and plugins
that enable maven to work with Eclipse/OSGi projects. Some of tycho
functionality, especially OSGi dependency injection, relies on maven
features only available in maven 3.0 which was very recently renamed
from 2.1. Since there is no maven 3.0 release yet, current tycho
distribution includes complete copy of maven 3.0-SNAPSHOT.
As for contributing to the project... well, this would be really
awesome . I think the best way to start is to try tycho and see what
is missing to support your projects and development workflow. Then
we can work together to implement missing features, fix bugs, etc. I
have simple demo that shows how to use tycho to build set of simple
projects and some user-level documentation. I will try to make this
available later today. I will also provide tycho dev env setup
steps, so you can start looking at the code if you want to. And
tycho distribution is already available from [1] (looks for the
latest .zip file)
I hope it answers your questions, but feel free to ask more,
especially if something is not clear or does not make sense.
--
Regards,
Igor Fedorenko
[1]
http://repository.sonatype.org/service/local/repositories/eclipse-snapshots/content/org/codehaus/tycho/tycho-distribution/0.3.0-SNAPSHOT/
Hi,
My company has been using Maven 1 for a couple of years now and
we are looking to make the transition over to the Maven 2 world
(waiting for the best opportunity)! The UI for most of our
applications are RCP based. The build process for the UI is
using the PDE and is completely autonomous from our middle tier
build with Maven. We are hoping that with the transition to
Maven 2 there would be some new functionality to allow for
RCP/OSGi development. Unfortunately we have found that we may
not have waited long enough! There have been several options
that we have looked at to obtain bridge Maven and our Eclipse
* *Building Eclipse Plugins with Maven 2
(http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html)*
<http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html%29*>
In this articles the authors describe in detail how they
integrated Maven2 and Eclipse. One aspect of their approach that
I did like was how they made use of the manifest file to define
the dependencies for the project (similar to how Eclipse works);
however they need to use the 'Required-Bundle' tags rather than
the improved 'Import-Packages'. Though well documented this
approach wasn't favoured as it did not offer the Mojos re-built in
a repo (they just offer the code for the Mojos but they don't make
their Mojos available) and the article was written in 2006.
The
company, Princeton software, was bought by IBM so it is hard to
get a hold of the developers for the project.
* *CodeHaus Maven PDE plugin
(http://mojo.codehaus.org/pde-maven-plugin)*
<http://mojo.codehaus.org/pde-maven-plugin%29*> This Mojo triggers
the PDE build from Maven. Though this approach would be fairly
straight forward in that the regular PDE mechanism can be used for
building the RCP application there are several drawbacks we see
PDE doesn't offer any way to easily integrate Maven 2 report
tooling into its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more Ant
based build cycle)
* *Felix Bundle Plugin for Maven
(http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)*
<http://felix.apache.org/site/mavem-bundle-plugin-bnd.html%29*> This
Mojo is based on the BND tooling. In this approach all the
dependencies are specified in the POM and manifest is generated
during the package lifecycle in Maven. There are specific
commands to provide the 'Export-Package',
'Private-Package', etc. However the BND tooling will
analyze the byte code to determine
some information such as the 'Import-Packages'. Though this
tooling works well for generating OSGi bundles it does not
leverage the tooling available in Eclipse. Once you have your
plugin working with its dependencies in Eclipse you then need to
rework your POM to ensure that the manifest that is generated is
equivalent to that which you now have in Eclipse. This is not
always a trivial process. Given that limitation this is the
process that is favoured at the moment. Some pros about this
+ What is nice about this approach is that everything is done in
Maven allowing you to now hook all the Maven reporting plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that your
bundles cannot be of the format of a jar within the bundle - they
have to be more like regular jars to be used by Maven)
+ Generate target platform in Maven
However after reading the article 'Jason Van Zyl Discusses
Sonatype, The Eclipse Foundation and Maven'
(http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven)
we believe that Tycho seems to be the up and coming solution to
bridging the world of OSGi and Maven. So I have done some
* At the beginning of the Tycho development it was a set of plugins
to provide building with the PDE compiler (as it
understands the
whole OSGi dependency/class loading issues), 'osgi-bundle'
lifecycle, generation of POM, etc. Now it seems to have morphed
into Maven 2.1? Is Tycho and M2Eclipse the basis of the
development for Maven 2.1?
* Will the new version be able to do everything with the manifest
that Maven 2.0 does with the POM? Through the manifest be able to
tell what dependencies are required? What if those dependencies
are only through Import-Packages (with a version to make life
easier)? Will the integration with the p2 enable M2Eclipse to
determine which bundles supply a given package and add the
required dependencie between the projects?
* Will the p2 integration be on top of the existing Maven repo or a
seperate repo to get bundles from?
* What is the timeline/gameplan for Tycho development at this point?
So as you can see we are really just starting out down this
path. We would be willing to help with development if we find
an area that we can contribute effectively into the project.
However as of right now we just want a starting point to start
getting our projects configured to using Tycho. Could you point
us in the right direction? The ReadMe file in the release now
is the one for the Apache Maven, so it doesn't really help with
the configuration of a project using Tycho. Is it the same
configuration as before? Should we be using a different version
(previous version than 0.3.0)?
Thanks, Any help you can give would be appreciated!
Alex
---------------------------------------------------------------------
http://xircles.codehaus.org/manage_email
hek
2008-09-04 10:57:36 UTC
Permalink
Hi,

I'm having serious problems testing the demo.

The problem occurs when the "custom" maven tries to acces repositories. I'm
sitting behind a firewall and must access repos through a proxy. This works
fine in a normal maven setup (setting proxy in settings.xml) on the same
machine. But the tycho-maven ignores proxy settings. I have added proxy
settings in settings.xml in users home directory, tychos settings, and also
java's proxy settings.

Any idea what the problem is? Could it be a bug in
plexus-classworlds-1.2-alpha-13.jar?

thankful for any input

/Henrik

C:\tychodemo>c:/tycho/bin/mvn -U
org.codehaus.tycho:maven-tycho-plugin:generate-poms -DgroupId=tycho.demo
-Dtycho.targetPlatform="c:/Program Files/eclipse"

C:\tychodemo>set M2_HOME=c:\tycho
Listening for transport dt_socket at address: 4000
[INFO] Using c:\Program Files\eclipse eclipse target platform
[INFO] Found 956 bundles
[INFO] snapshot org.codehaus.tycho:maven-tycho-plugin:0.3.0-SNAPSHOT:
checking f
or updates from ibiblio
[WARNING] repository metadata for: 'snapshot
org.codehaus.tycho:maven-tycho-plug
in:0.3.0-SNAPSHOT' could not be retrieved from repository: ibiblio due to an
err
or: Error transferring file
[INFO] Repository 'ibiblio' will be blacklisted
[INFO] snapshot org.codehaus.tycho:maven-tycho-plugin:0.3.0-SNAPSHOT:
checking f
or updates from baka
[WARNING] repository metadata for: 'snapshot
org.codehaus.tycho:maven-tycho-plug
in:0.3.0-SNAPSHOT' could not be retrieved from repository: baka due to an
error:
Error transferring file
[INFO] Repository 'baka' will be blacklisted
[INFO] snapshot org.codehaus.tycho:maven-tycho-plugin:0.3.0-SNAPSHOT:
checking f
or updates from julien
.....
Post by Igor Fedorenko
Post by Alexandre Sauvé
Igor,
That's great news! I will definitely try Tycho once I get an idea on
the 'How'...
Demo script
http://docs.codehaus.org/display/M2ECLIPSE/tycho+technology+demo+script
Some user docs
http://docs.codehaus.org/display/M2ECLIPSE/Tycho+user+docs
Post by Alexandre Sauvé
For me I am more interested in the 'manifest-first' as I have worked
already with Felix and find that generating the manifest is not exactly
the Eclipse way to go... So that being said it seems that you have most
of everything in place for me to try! I would like some more
information on what is missing/implemented in the artifact repository
front. In your email you mention generating a target platform from a p2
repo, that is terrific! But how do you configure such a repo or have a
p2 implementation fronting an existing Maven repo. If this work is
currently on going how do you guys work with your artifact as of today?
Is your target platform prebuilt and you point your maven build toward
your target platform? Will your example cover this?
Yes, example shows how to use existing eclipse installation as build
target platform, and I suggest this is what you use, at least initially,
to make sure other tycho functionality works first.
Artifact repositories support is the least explored area, and the code
that I wrote for p2 support was really meant to prove possibility to run
p2 client inside maven runtime. It is only able to consume artifacts
from existing p2 repositories, but it is not able to generate p2
repository. Also, tycho is not able to deploy build results into maven
artifact repository yet, not in a meaningful way, at least.
So, consider yourself warned, and if you still want to try p2 repo
support, here are few pointers. m2e parent pom [1] has "e34-p2" profile
that defines few extra repositories with p2 layout as well as few
dependencyManagement dependencies that define p2 root installable units
(IUs). When running m2e with e34-p2 profile enabled but without
tycho.targetPlatform parameter, tycho will start p2 client and will
instruct it to download/create/configure eclipse installation with all
p2 IUs mentioned in the profile and all their dependencies. This eclipse
install will be created under generated name in ~/.m2/p2/targets folder
and will be used as build target platform. Also, you almost certainly
want to read some p2 documentation, but [2] is the only place I know.
It is also almost certain that current prototype p2 repository support
will go away in its existing form. I have general dissatisfaction with
the current behaviour, but do not know how to make it better yet.
[1]
http://svn.sonatype.org/m2eclipse/trunk/org.maven.ide.eclipse.parent/pom.xml
[2] http://wiki.eclipse.org/Category:Equinox_p2
Post by Alexandre Sauvé
Looking forward to getting my hands dirty.
Alex
Hello, Alexandre and others.
First of all, I have to apologize for keeping Tycho development
plans and progress to myself. I would like to thank you for bringing
this up and will try to both explain our grand vision and what we
already have or will have implemented in the near future.
The big picture. Ultimately, we want tycho to be one-stop solution
for doing Eclipse and OSGi development with Maven 2 (actually, 3,
more on this later). We believe there are two distinct development
workflows, when developer explicitly creates and maintains OSGi
manifest and other Eclipse/OSGi metadata (we call it
"manifest-first") and when OSGi metadata is generated by the build
based on information available from pom.xml ("pom-first",
naturally). We plan to support both development workflows.
In manifest-first mode, tycho will use Eclipse/OSGi metadata and
OSGi rules to calculate project dependencies dynamically, at build
time. It will support all attributes supported by Eclipse OSGi
resolver (Require-Bundle, Import-Package, Eclipse-GenericRequire,
etc). It will use proper classpath access rules during compilation.
It will support all projects supported by PDE and will use PDE/JDT
project metadata where applicable. One important design goal is to
make sure there is no duplication of metadata between pom.xml files
and Eclipse/OSGi config files. In fact, tycho will support
"pom-less" projects, where all required build metadata is derived
from Eclipse/OSGi config files.
In pom-first mode current plan is to provide similar set of features
as in felix/bnd plugin, although I do not know if we'll be able to
share any of the code. Additionally, Tycho will support
Eclipse-friendlier Require-Bundle and will provide better support
for developing multiple related OSGi bundles (I have not checked
recently, so felix/bnd may already support these).
In both modes tycho will support remote repositories both as source
and sink for artifacts. We plan to support maven repositories, p2
and update sites, although level of support will likely vary. There
will also be integration between m2e, tycho and pde to make the
three work nicely together.
So these are the plans... Disclaimer: plans do change! ;-)
Now to what tycho is already able to do. Our first goal was to
enable m2e continues build, so we started with manifest-first mode
and I believe covered most of manifest-first features described
above. Tycho already uses Eclipse/OSGi metadata to resolve project
dependencies by OSGi rules and injects these dependencies into maven
project model dynamically, at build time. It supports bundle,
fragment, feature and update site projects (shame on me, but no RCP
application yet). It knows how to run junit test plugins using OSGi
runtime. Two big features that are still missing, are support for
pom-less projects and work with artifact repositories, although
there is prototype of target platform materialization from p2
repository already. There is also some rudimentary implementation of
pom-first mode, but its usability outside of m2e build context is
probably limited. Many smaller features are still missing and I am
certain there are quite a few bugs too, but I think overall tycho
code is in reasonably good shape already.
Few words about relationship between maven and tycho. Tycho is not
morphing into maven, but it provides maven extensions and plugins
that enable maven to work with Eclipse/OSGi projects. Some of tycho
functionality, especially OSGi dependency injection, relies on maven
features only available in maven 3.0 which was very recently renamed
from 2.1. Since there is no maven 3.0 release yet, current tycho
distribution includes complete copy of maven 3.0-SNAPSHOT.
As for contributing to the project... well, this would be really
awesome . I think the best way to start is to try tycho and see what
is missing to support your projects and development workflow. Then
we can work together to implement missing features, fix bugs, etc. I
have simple demo that shows how to use tycho to build set of simple
projects and some user-level documentation. I will try to make this
available later today. I will also provide tycho dev env setup
steps, so you can start looking at the code if you want to. And
tycho distribution is already available from [1] (looks for the
latest .zip file)
I hope it answers your questions, but feel free to ask more,
especially if something is not clear or does not make sense.
--
Regards,
Igor Fedorenko
[1]
http://repository.sonatype.org/service/local/repositories/eclipse-snapshots/content/org/codehaus/tycho/tycho-distribution/0.3.0-SNAPSHOT/
Hi,
My company has been using Maven 1 for a couple of years now and
we are looking to make the transition over to the Maven 2 world
(waiting for the best opportunity)! The UI for most of our
applications are RCP based. The build process for the UI is
using the PDE and is completely autonomous from our middle tier
build with Maven. We are hoping that with the transition to
Maven 2 there would be some new functionality to allow for
RCP/OSGi development. Unfortunately we have found that we may
not have waited long enough! There have been several options
that we have looked at to obtain bridge Maven and our Eclipse
* *Building Eclipse Plugins with Maven 2
(http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html)*
<http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html%29*>
In this articles the authors describe in detail how they
integrated Maven2 and Eclipse. One aspect of their approach that
I did like was how they made use of the manifest file to define
the dependencies for the project (similar to how Eclipse works);
however they need to use the 'Required-Bundle' tags rather than
the improved 'Import-Packages'. Though well documented this
approach wasn't favoured as it did not offer the Mojos re-built in
a repo (they just offer the code for the Mojos but they don't make
their Mojos available) and the article was written in 2006.
The
company, Princeton software, was bought by IBM so it is hard to
get a hold of the developers for the project.
* *CodeHaus Maven PDE plugin
(http://mojo.codehaus.org/pde-maven-plugin)*
<http://mojo.codehaus.org/pde-maven-plugin%29*> This Mojo triggers
the PDE build from Maven. Though this approach would be fairly
straight forward in that the regular PDE mechanism can be used for
building the RCP application there are several drawbacks we see
PDE doesn't offer any way to easily integrate Maven 2 report
tooling into its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more Ant
based build cycle)
* *Felix Bundle Plugin for Maven
(http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)*
<http://felix.apache.org/site/mavem-bundle-plugin-bnd.html%29*> This
Mojo is based on the BND tooling. In this approach all the
dependencies are specified in the POM and manifest is generated
during the package lifecycle in Maven. There are specific
commands to provide the 'Export-Package',
'Private-Package', etc. However the BND tooling will
analyze the byte code to determine
some information such as the 'Import-Packages'. Though this
tooling works well for generating OSGi bundles it does not
leverage the tooling available in Eclipse. Once you have your
plugin working with its dependencies in Eclipse you then need to
rework your POM to ensure that the manifest that is generated is
equivalent to that which you now have in Eclipse. This is not
always a trivial process. Given that limitation this is the
process that is favoured at the moment. Some pros about this
+ What is nice about this approach is that everything is done in
Maven allowing you to now hook all the Maven reporting plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that your
bundles cannot be of the format of a jar within the bundle - they
have to be more like regular jars to be used by Maven)
+ Generate target platform in Maven
However after reading the article 'Jason Van Zyl Discusses
Sonatype, The Eclipse Foundation and Maven'
(http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven)
we believe that Tycho seems to be the up and coming solution to
bridging the world of OSGi and Maven. So I have done some
* At the beginning of the Tycho development it was a set of plugins
to provide building with the PDE compiler (as it
understands the
whole OSGi dependency/class loading issues), 'osgi-bundle'
lifecycle, generation of POM, etc. Now it seems to have morphed
into Maven 2.1? Is Tycho and M2Eclipse the basis of the
development for Maven 2.1?
* Will the new version be able to do everything with the manifest
that Maven 2.0 does with the POM? Through the manifest be able to
tell what dependencies are required? What if those dependencies
are only through Import-Packages (with a version to make life
easier)? Will the integration with the p2 enable M2Eclipse to
determine which bundles supply a given package and add the
required dependencie between the projects?
* Will the p2 integration be on top of the existing Maven repo or a
seperate repo to get bundles from?
* What is the timeline/gameplan for Tycho development at this point?
So as you can see we are really just starting out down this
path. We would be willing to help with development if we find
an area that we can contribute effectively into the project.
However as of right now we just want a starting point to start
getting our projects configured to using Tycho. Could you point
us in the right direction? The ReadMe file in the release now
is the one for the Apache Maven, so it doesn't really help with
the configuration of a project using Tycho. Is it the same
configuration as before? Should we be using a different version
(previous version than 0.3.0)?
Thanks, Any help you can give would be appreciated!
Alex
---------------------------------------------------------------------
http://xircles.codehaus.org/manage_email
---------------------------------------------------------------------
http://xircles.codehaus.org/manage_email
--
View this message in context: http://www.nabble.com/Fwd%3A-tycho---the-future-tp19055385p19308007.html
Sent from the Maven Eclipse - User mailing list archive at Nabble.com.
Igor Fedorenko
2008-09-04 14:44:52 UTC
Permalink
Apparently, current maven 3.0 does not honour proxy settings. I will
need to get new maven 3.0 build into tycho. Hopefully, this will happen
today. I will send another email when this is fixed.
Post by hek
Hi,
I'm having serious problems testing the demo.
The problem occurs when the "custom" maven tries to acces repositories. I'm
sitting behind a firewall and must access repos through a proxy. This works
fine in a normal maven setup (setting proxy in settings.xml) on the same
machine. But the tycho-maven ignores proxy settings. I have added proxy
settings in settings.xml in users home directory, tychos settings, and also
java's proxy settings.
Any idea what the problem is? Could it be a bug in
plexus-classworlds-1.2-alpha-13.jar?
thankful for any input
/Henrik
C:\tychodemo>c:/tycho/bin/mvn -U
org.codehaus.tycho:maven-tycho-plugin:generate-poms -DgroupId=tycho.demo
-Dtycho.targetPlatform="c:/Program Files/eclipse"
C:\tychodemo>set M2_HOME=c:\tycho
Listening for transport dt_socket at address: 4000
[INFO] Using c:\Program Files\eclipse eclipse target platform
[INFO] Found 956 bundles
checking f
or updates from ibiblio
[WARNING] repository metadata for: 'snapshot
org.codehaus.tycho:maven-tycho-plug
in:0.3.0-SNAPSHOT' could not be retrieved from repository: ibiblio due to an
err
or: Error transferring file
[INFO] Repository 'ibiblio' will be blacklisted
checking f
or updates from baka
[WARNING] repository metadata for: 'snapshot
org.codehaus.tycho:maven-tycho-plug
in:0.3.0-SNAPSHOT' could not be retrieved from repository: baka due to an
Error transferring file
[INFO] Repository 'baka' will be blacklisted
checking f
or updates from julien
.....
Post by Igor Fedorenko
Post by Alexandre Sauvé
Igor,
That's great news! I will definitely try Tycho once I get an idea on
the 'How'...
Demo script
http://docs.codehaus.org/display/M2ECLIPSE/tycho+technology+demo+script
Some user docs
http://docs.codehaus.org/display/M2ECLIPSE/Tycho+user+docs
Post by Alexandre Sauvé
For me I am more interested in the 'manifest-first' as I have worked
already with Felix and find that generating the manifest is not exactly
the Eclipse way to go... So that being said it seems that you have most
of everything in place for me to try! I would like some more
information on what is missing/implemented in the artifact repository
front. In your email you mention generating a target platform from a p2
repo, that is terrific! But how do you configure such a repo or have a
p2 implementation fronting an existing Maven repo. If this work is
currently on going how do you guys work with your artifact as of today?
Is your target platform prebuilt and you point your maven build toward
your target platform? Will your example cover this?
Yes, example shows how to use existing eclipse installation as build
target platform, and I suggest this is what you use, at least initially,
to make sure other tycho functionality works first.
Artifact repositories support is the least explored area, and the code
that I wrote for p2 support was really meant to prove possibility to run
p2 client inside maven runtime. It is only able to consume artifacts
from existing p2 repositories, but it is not able to generate p2
repository. Also, tycho is not able to deploy build results into maven
artifact repository yet, not in a meaningful way, at least.
So, consider yourself warned, and if you still want to try p2 repo
support, here are few pointers. m2e parent pom [1] has "e34-p2" profile
that defines few extra repositories with p2 layout as well as few
dependencyManagement dependencies that define p2 root installable units
(IUs). When running m2e with e34-p2 profile enabled but without
tycho.targetPlatform parameter, tycho will start p2 client and will
instruct it to download/create/configure eclipse installation with all
p2 IUs mentioned in the profile and all their dependencies. This eclipse
install will be created under generated name in ~/.m2/p2/targets folder
and will be used as build target platform. Also, you almost certainly
want to read some p2 documentation, but [2] is the only place I know.
It is also almost certain that current prototype p2 repository support
will go away in its existing form. I have general dissatisfaction with
the current behaviour, but do not know how to make it better yet.
[1]
http://svn.sonatype.org/m2eclipse/trunk/org.maven.ide.eclipse.parent/pom.xml
[2] http://wiki.eclipse.org/Category:Equinox_p2
Post by Alexandre Sauvé
Looking forward to getting my hands dirty.
Alex
Hello, Alexandre and others.
First of all, I have to apologize for keeping Tycho development
plans and progress to myself. I would like to thank you for bringing
this up and will try to both explain our grand vision and what we
already have or will have implemented in the near future.
The big picture. Ultimately, we want tycho to be one-stop solution
for doing Eclipse and OSGi development with Maven 2 (actually, 3,
more on this later). We believe there are two distinct development
workflows, when developer explicitly creates and maintains OSGi
manifest and other Eclipse/OSGi metadata (we call it
"manifest-first") and when OSGi metadata is generated by the build
based on information available from pom.xml ("pom-first",
naturally). We plan to support both development workflows.
In manifest-first mode, tycho will use Eclipse/OSGi metadata and
OSGi rules to calculate project dependencies dynamically, at build
time. It will support all attributes supported by Eclipse OSGi
resolver (Require-Bundle, Import-Package, Eclipse-GenericRequire,
etc). It will use proper classpath access rules during compilation.
It will support all projects supported by PDE and will use PDE/JDT
project metadata where applicable. One important design goal is to
make sure there is no duplication of metadata between pom.xml files
and Eclipse/OSGi config files. In fact, tycho will support
"pom-less" projects, where all required build metadata is derived
from Eclipse/OSGi config files.
In pom-first mode current plan is to provide similar set of features
as in felix/bnd plugin, although I do not know if we'll be able to
share any of the code. Additionally, Tycho will support
Eclipse-friendlier Require-Bundle and will provide better support
for developing multiple related OSGi bundles (I have not checked
recently, so felix/bnd may already support these).
In both modes tycho will support remote repositories both as source
and sink for artifacts. We plan to support maven repositories, p2
and update sites, although level of support will likely vary. There
will also be integration between m2e, tycho and pde to make the
three work nicely together.
So these are the plans... Disclaimer: plans do change! ;-)
Now to what tycho is already able to do. Our first goal was to
enable m2e continues build, so we started with manifest-first mode
and I believe covered most of manifest-first features described
above. Tycho already uses Eclipse/OSGi metadata to resolve project
dependencies by OSGi rules and injects these dependencies into maven
project model dynamically, at build time. It supports bundle,
fragment, feature and update site projects (shame on me, but no RCP
application yet). It knows how to run junit test plugins using OSGi
runtime. Two big features that are still missing, are support for
pom-less projects and work with artifact repositories, although
there is prototype of target platform materialization from p2
repository already. There is also some rudimentary implementation of
pom-first mode, but its usability outside of m2e build context is
probably limited. Many smaller features are still missing and I am
certain there are quite a few bugs too, but I think overall tycho
code is in reasonably good shape already.
Few words about relationship between maven and tycho. Tycho is not
morphing into maven, but it provides maven extensions and plugins
that enable maven to work with Eclipse/OSGi projects. Some of tycho
functionality, especially OSGi dependency injection, relies on maven
features only available in maven 3.0 which was very recently renamed
from 2.1. Since there is no maven 3.0 release yet, current tycho
distribution includes complete copy of maven 3.0-SNAPSHOT.
As for contributing to the project... well, this would be really
awesome . I think the best way to start is to try tycho and see what
is missing to support your projects and development workflow. Then
we can work together to implement missing features, fix bugs, etc. I
have simple demo that shows how to use tycho to build set of simple
projects and some user-level documentation. I will try to make this
available later today. I will also provide tycho dev env setup
steps, so you can start looking at the code if you want to. And
tycho distribution is already available from [1] (looks for the
latest .zip file)
I hope it answers your questions, but feel free to ask more,
especially if something is not clear or does not make sense.
--
Regards,
Igor Fedorenko
[1]
http://repository.sonatype.org/service/local/repositories/eclipse-snapshots/content/org/codehaus/tycho/tycho-distribution/0.3.0-SNAPSHOT/
Hi,
My company has been using Maven 1 for a couple of years now and
we are looking to make the transition over to the Maven 2 world
(waiting for the best opportunity)! The UI for most of our
applications are RCP based. The build process for the UI is
using the PDE and is completely autonomous from our middle tier
build with Maven. We are hoping that with the transition to
Maven 2 there would be some new functionality to allow for
RCP/OSGi development. Unfortunately we have found that we may
not have waited long enough! There have been several options
that we have looked at to obtain bridge Maven and our Eclipse
* *Building Eclipse Plugins with Maven 2
(http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html)*
<http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html%29*>
In this articles the authors describe in detail how they
integrated Maven2 and Eclipse. One aspect of their approach that
I did like was how they made use of the manifest file to define
the dependencies for the project (similar to how Eclipse works);
however they need to use the 'Required-Bundle' tags rather than
the improved 'Import-Packages'. Though well documented this
approach wasn't favoured as it did not offer the Mojos re-built in
a repo (they just offer the code for the Mojos but they don't make
their Mojos available) and the article was written in 2006.
The
company, Princeton software, was bought by IBM so it is hard to
get a hold of the developers for the project.
* *CodeHaus Maven PDE plugin
(http://mojo.codehaus.org/pde-maven-plugin)*
<http://mojo.codehaus.org/pde-maven-plugin%29*> This Mojo triggers
the PDE build from Maven. Though this approach would be fairly
straight forward in that the regular PDE mechanism can be used for
building the RCP application there are several drawbacks we see
PDE doesn't offer any way to easily integrate Maven 2 report
tooling into its build process (checkstyle, code coverage, ect.)
PDE is another technology for our developers to learn (more Ant
based build cycle)
* *Felix Bundle Plugin for Maven
(http://felix.apache.org/site/mavem-bundle-plugin-bnd.html)*
<http://felix.apache.org/site/mavem-bundle-plugin-bnd.html%29*> This
Mojo is based on the BND tooling. In this approach all the
dependencies are specified in the POM and manifest is generated
during the package lifecycle in Maven. There are specific
commands to provide the 'Export-Package',
'Private-Package', etc. However the BND tooling will
analyze the byte code to determine
some information such as the 'Import-Packages'. Though this
tooling works well for generating OSGi bundles it does not
leverage the tooling available in Eclipse. Once you have your
plugin working with its dependencies in Eclipse you then need to
rework your POM to ensure that the manifest that is generated is
equivalent to that which you now have in Eclipse. This is not
always a trivial process. Given that limitation this is the
process that is favoured at the moment. Some pros about this
+ What is nice about this approach is that everything is done in
Maven allowing you to now hook all the Maven reporting plugins.
+ Leverage Maven 2 Repo for your dependent bundles (note that your
bundles cannot be of the format of a jar within the bundle - they
have to be more like regular jars to be used by Maven)
+ Generate target platform in Maven
However after reading the article 'Jason Van Zyl Discusses
Sonatype, The Eclipse Foundation and Maven'
(http://www.infoq.com/news/2008/08/van-zyl-eclipse-sonatype-maven)
we believe that Tycho seems to be the up and coming solution to
bridging the world of OSGi and Maven. So I have done some
* At the beginning of the Tycho development it was a set of plugins
to provide building with the PDE compiler (as it understands the
whole OSGi dependency/class loading issues), 'osgi-bundle'
lifecycle, generation of POM, etc. Now it seems to have morphed
into Maven 2.1? Is Tycho and M2Eclipse the basis of the
development for Maven 2.1?
* Will the new version be able to do everything with the manifest
that Maven 2.0 does with the POM? Through the manifest be able to
tell what dependencies are required? What if those dependencies
are only through Import-Packages (with a version to make life
easier)? Will the integration with the p2 enable M2Eclipse to
determine which bundles supply a given package and add the
required dependencie between the projects?
* Will the p2 integration be on top of the existing Maven repo or a
seperate repo to get bundles from?
* What is the timeline/gameplan for Tycho development at this point?
So as you can see we are really just starting out down this
path. We would be willing to help with development if we find
an area that we can contribute effectively into the project.
However as of right now we just want a starting point to start
getting our projects configured to using Tycho. Could you point
us in the right direction? The ReadMe file in the release now
is the one for the Apache Maven, so it doesn't really help with
the configuration of a project using Tycho. Is it the same
configuration as before? Should we be using a different version
(previous version than 0.3.0)?
Thanks, Any help you can give would be appreciated!
Alex
---------------------------------------------------------------------
http://xircles.codehaus.org/manage_email
---------------------------------------------------------------------
http://xircles.codehaus.org/manage_email
Continue reading on narkive:
Loading...