It looks like OpenCMIS is the best java lib for CMIS integration (according to this forum!). I can't download the source (stuck behind a firewall)- is there a (client) JAR bundle available for download, anywhere??? Thanks, Gavin
No, there is no bundle yet. There is no official release of OpenCMIS at the moment.
If you're brave and persistent you can collect all the OpenCMIS Jars (without dependencies) from the build server.
Or, you grab the the OpenCMIS Swing Client and extract all the Jars you need (with dependencies).
Florian
Related
I am using eclipse in Windows and a simple JSF example from the book Java EE7 Recipes. I cannot find the following jars: "javax.enterprisse.context.RequestScoped" and "javax.faces.bean.ManagedBean". I have searched for the files both in my pc and the net with no luck. Is there a general way to find the correct .jar files?
There are loads of sites available on web to find jars for a given class. Some popular sites are Help4J, GrepCode, findJar etc. It comes handy for developers.
I recommend you to install Netbeans with JavaEE Bundle for rapidly develop Java EE Apps because the whole infrastructure is provided. https://netbeans.org/downloads/
Thanks everyone for providing input. I found a download for javax.enterprise.context.RequestScoped. I found that when you type "javax.enterprise.context.RequestScoped download" in google it brings you to a download site. That's all that was needed.
I'm looking for a way to automatically install a couple of bundles into an OSGi application, ideally by some kind of batch file / console script so as to allow us to embed it into our build process.
The ideal situation would allow me to just pass the update site URLs to the console and have it download and install them as that would spare from having to install the jars one by one.
Is this possible? Beware that the application I'm talking about is not Eclipse although it contains a couple of Eclipse plugin jars in its bundles directory. I reckon this fact may well imply a slightly different approach to the situation, although I'm not totally sure.
At the moment I'm in control of the application's OSGi console (p2), so I guess that would be the right tool to use, from what I've read.
Thanks
There are several ways to go about this (apart from using p2 which you already mention):
Use the Apache Felix Gogo shell, which has commands to install bundles from a URL, and create a script for that that is executed at startup.
Use the Apache Felix File Install bundle, which allows you to put all bundles in a "hot deploy" folder and automatically installs them.
Use Apache ACE, which is a full blown provisioning solution that allows you to map artifacts to target systems.
Use a Bnd feature to create an executable jar that embeds both the OSGi framework and all bundles and launches them when you start the jar.
Use Apache Karaf features, which allow you to define a list of URLs as a feature and install that feature (using a shell similarly to #1).
There's a lot more to say about each of them, but these are the most-used options I'm aware of.
I've been beating my head against a wall for about 6 months now and have not found a concise way of understanding the mechanism for developing an eclipse plugin with third-party resources.
We are attempting to develop an Eclipse ODA to ride on top of in-house Spring-based code that accesses a REST based info set.
In broad strokes - this is what I feel that we need to be able to do:
Augment our maven artifacts with Eclipse bundle information using tycho or a the felix bundle plugin.
Set up a plugin project through Eclipse for the ODA Implementation & UI.
Have Tycho generate the poms etc for the plugin.
Now here's where I get muddy. I understand that there are two approaches
Manifest-First - which is the standard mechanism for defining a plugin's dependencies
POM-First - which provides dependencies via Maven's resolution mechanisms.
I'm not entirely sure where to begin trying to start doing this as I've never worked on developing an eclipse plugin.
One of the other questions I have is, how does a developer of an eclipse plugin (maven aside) leverage already existing third-party code (i.e. Apache HttpClient 4.x)? Do they have to download the jars, dump them into a directory within the project, add to classpath, then go from there or is there a "repository" mechanism similar to what is used with ivy, maven, gradle?
Thanks in advance and I apologize if I was rambling a bit with that.
Disclaimer: Your question is very broad, so it is impossible to answer it completely. Still, I can give you some hints so that you know what to search for.
In the Eclipse universe, the primary source for libraries (in the sense of binary dependencies) are p2 repositories. However, since p2 repositories are rarely used outside of the Eclipse context, you won't e.g. find a p2 repository on the Apache HTTP Client project's download page.
To account for this problem, there is the Eclipse Orbit Project which provides libraries used by Eclipse projects in p2 repositories.
If you can't find the library or library version in the Eclipse Orbit, you may also be able to use the libraries from Maven repositories. This is for example supported by Tycho via the pomDependencies=consider mechanism.
Note however that Eclipse plug-ins can only depend on libraries which are OSGi bundles. So if the library in the Maven repository is not yet an OSGi bundle, you need to convert it to an OSGi bundle first, e.g. with the maven-bundle-plugin and the Embed-Dependency mechanism.
The best way for an Eclipse plugin to consume libraries is as OSGi bundles. You just install those bundles into your target platform and reference them in the same way as eclipse.org plugins. Some of the library providers already offer their libraries as OSGi bundles. Absent that, you can typically turn a plain library jar into an OSGi bundle simply by adding a few manifest entries.
Depending on the build system you use and whether the libraries you need are available as OSGi bundles packaged into an online p2 repository, you can reference the URL and rely on your build to download and install the bundle.
If question of choosing a build system for Eclipse plugins with dependencies is still relevant:
Today I released new gradle plugin: Wuff version 0.0.1, which (I think) completely solves the problem. It allows to build Eclipse bundles and applications as they would be "normal" Gradle projects. All OSGi woodoo is auto-generated (although customizable). All dependencies are usual maven dependencies - regardless of whether dependency is OSGi or "normal" library.
Sources and doc: https://github.com/akhikhl/wuff
We are looking at rearchitecting our web application and want to move to a more modular solution, OSGi seems to meet a lot of our needs.
I've come across the Apache Felix project and taken it for a spin. It looks solid yet I find the development cycle a bit slow as it requires a maven build of the bundle(s) to make any code changes effective.
Instead I would like to be able to reload a bundle once classes have been compiled by Eclipse, without any extra building/packaging. Similar to how Tomcat and other servlet containers support deployment of "exploded" war files.
Is this possible to do with Felix or any other OSGi container?
In the Gogo shell, you can do:
install reference:file:/path/to/exploded/directory
This will install an exploded bundle. The format of the exploded directory should be exact that of a bundle JAR file.
Apache Felix FileInstall supports exploded bundles out of the box. Just install it, and put a directory with your bundle in the load directory (or configure FileInstall to look somewhere else).
Not exactly answering your question, but if you have issues with the build cycle, you should take a look at bndtools, which is a plugin for Eclipse that a.o. automatically builds and deploys your bundles in a running framework when your code changes.
How to make a standalone lift application? Which tools/libraries to use? How does the performance compare to using lift application as a war in some application server?
With onejar maven plugin http://onejar-maven-plugin.googlecode.com/svn/mavensite/usage.html and maven I could package jetty and project with dependencies inside one jar.
The part of the question on performance doesn't really fit with the rest. You are primarily asking how to package the Lift application as a single JAR/WAR. This doesn't have anything to do with the runtime.
At runtime you will still be running inside a Servlet container (could be Jetty, Tomcat or a full-blown Java EE server). How you package your application won't affect the performance.
You could take a look at Hudson (a great Continuous Integration Server) to see how they deliver as a single WAR file that contains an embedded Servlet container. You can download the WAR file and run it from the command line: java -jar hudson.war
I know this is an old question, but...
If you are using sbt, I wrote a plugin to produce 'executable' wars like those mentioned above.
https://github.com/glenford/sbt-jetty-embed