Grab the HBase POM here (not official) and then set HBASE_HOME and run the deploy_deps.sh script.

Hope it helps :)

First of all I wanted to put my Rails application into a Maven like directory structure so I created /src/main/rails and put the app in there,  then I knocked up a pretty standard POM for a WAR file.  Next up I wanted to Warble the project so I first up I installed the gem.

pdodds:(svn)trunk[trunk:4184]/src/main/rails$ sudo gem install warbler
Bulk updating Gem source index for: http://gems.rubyforge.org
Successfully installed warbler-0.9.11
1 gem installed
Installing ri documentation for warbler-0.9.11...
Installing RDoc documentation for warbler-0.9.11...
pdodds:(svn)trunk[trunk:4184]/src/main/rails$

Then I pluginize the Warble so that it will be available in my project using warble pluginize.

Next up I wanted to get my Maven pom sorted out – the quickest way I could find to get Warble integrated was through the jruby-rake-plugin. Adding the following plugin to my pom.xml ensures that the gems that I need are installed by the jruby plugin and then warble can be called in the compile phase.

<plugin>
	<groupId>org.jruby.plugins</groupId>
	<artifactId>jruby-rake-plugin</artifactId>
	<version>1.1.4</version>
	<executions>
		<execution>
			<id>install-gems</id>
			<phase>process-resources</phase>
				<goals>
					<goal>install-gems</goal>
				</goals>
				<configuration>
					<gems>warbler,rails</gems>
				</configuration>
		</execution>
		<execution>
				<id>build-war</id>
				<phase>compile</phase>
				<goals>
					<goal>rake</goal>
				</goals>
				<configuration>
					<launchDirectory>${basedir}/src/main/rails
					</launchDirectory>
			    	        <args>war:clean war</args>
				</configuration>
	           </execution>
	</executions>
</plugin>

In the first instance of the execution of the jruby plugin we pull down and install the gems that we are going to use, in the second we actually call the Warble goals in the project to create the WAR file.

In order to quickly integrate this process with the standard WAR building in Maven we need to configure the Maven WAR plugin, you could also change the Warble output but in the end I found this way worked when I wanted to use the Jetty plugin.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-war-plugin</artifactId>
	<configuration>
		<webappDirectory>${basedir}/src/main/rails/tmp</webappDirectory>
        </configuration>
</plugin>

While this is pretty brief hopefully it helps others get going and I’m very open to alternate or better ways to achieve the same goal.

The first thing I noticed about pulling Maven and JBoss together was that the EJB packaging didn’t seem quite as intuitive as I thought.  In the end I did end up using the EJB plugin and the dependency plugin to get the dependencies in place.  This meant including both the plugins in an EJB parent POM.

<plugin>
<artifactId>maven-ejb-plugin</artifactId>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
</manifest>
</archive>
<ejbVersion>3.0</ejbVersion>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin
</artifactId>
<executions>
<execution>
<id>copy</id>
<phase>compile</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>target/classes</outputDirectory>
<excludeScope>provided</excludeScope>
</configuration>
</execution>
</executions>
</plugin>

With that code in place you just need to ensure you set the packaging to EJB on your EJB’s. I thought that copying the dependencies into the target was probably the nicest way, also you need to watch your dependencies and ensure that those you don’t want to use have a scope of provided so they they don’t get bundled. At first I thought that the dependency embedding should have been part of the EJB plugin, but actually given the power of the dependency plugin it actually made more sense to use that.