Hello,

I felt the need to generate a dynamic import sql for a project that was based on hibernate.

The task proved to be a bit more advanced then a trivial thing. So here I share the way I hacked it to convince hibernate to use an import script generated on the fly.

Requirement, the project I am currently working on is a “service provision application”  which designates the application instances by the domain requests are destined to. The application therefore requires to fill the db in with some generated data as it kicks off for the first time. The solution is also handy any scenario that needs to alter import.sql based on some conditions.

First thing is to create a manager class to undertake the task. In my instance it was a spring based application therefore I needed to extend LocalSessionFactoryBean provided by spring. If you need to create a standalone / adhoc hibernate container you may embed the necessary code to your session factory class or so called HibernateUtil class.

Since we will be using our own SchemaExport, we must block hibernate.hbm2ddl.auto somehow in the properties file and set it to none. In my case since I was using spring, I just put hardcoded hibernate.hbm2ddl.auto = none in my applicationContext.xml file.

Then comes the generation of the sql on the fly. My sql was not a huge file therefore I chose to regenerate it with a FileStream accessed via BufferedReader and appended the altered SQL lines to my StringBuffer.

The next thing is to create a SchemaExport and set the importSQL. Here hibernate implementation wierdly only allows classpath relative import.sql references and removes the leading “/” which makes it impossible to refer a generated file residing somewhere in the file system (err, in the tmp path of the application server, runtime or OS, to be a good boy). What we do here is to replace the thread’s classloader with a fake classloader. We feed in a fake name for the import script and as we see the fake name back in the classloader requested as a stream via getResourceAsStream, we just return an input stream that reads whatever (or wherever) we prepared the sql.

By issuing a create request to SchemExport,  we are done. And we cleanup by restoring the original classloader of the thread we are executing on.

Below is the code that I used. By modifying as required, it should be good to use in stand alone / ad hoc / Teneo driven, etc environments. By the way, for those that are not aware of Eclipse EMF and Eclipse Teneo,  with the new sister project Texo, I highly recommend you get your hands on EMF and Teneo, I am sure you will love it.

package com.example.session;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.hibernate.HibernateException;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.hibernate.util.ConfigHelper;
import org.springframework.orm.hibernate3.LocalSessionFactoryBean;

public class ExampleSessionFactory extends LocalSessionFactoryBean {

	private static final String	FAKE_SCRIPT	= "__auto_generated_import.sql__";	//$NON-NLS-1$
	private StringBuffer		sql;

	/*
	 * (non-Javadoc)
	 *
	 * @see org.springframework.orm.hibernate3.LocalSessionFactoryBean#newSessionFactory(org.hibernate.cfg.Configuration)
	 */
	@Override
	protected SessionFactory newSessionFactory(Configuration config)
		throws HibernateException {
		final SessionFactory sessionFactory = config.buildSessionFactory();

		final String httpPort = CommonUtils.getHTTPPort();

		if ( this.schemaInitRequired(sessionFactory) ) {
			this.prepareSchema(config, httpPort);
		}

		return sessionFactory;
	}

	private void prepareSchema(Configuration config, final String httpPort) {
		try {
			final InputStream is = ConfigHelper.getResourceAsStream("/import.sql"); //$NON-NLS-1$
			final InputStreamReader importFileReader = new InputStreamReader(is);

			this.sql = new StringBuffer();

			this.logger.info("Preparing import script..."); //$NON-NLS-1$
			final BufferedReader reader = new BufferedReader(importFileReader);
			for ( String raw = reader.readLine(); raw != null; raw = reader.readLine() ) {
				final String replaced1 = raw.replaceAll("%host%", InetAddress.getLocalHost().getHostName()); //$NON-NLS-1$
				final String replaced2 = replaced1.replaceAll("%port%", httpPort); //$NON-NLS-1$
				this.sql.append(replaced2);
				this.sql.append("\n"); //$NON-NLS-1$
			}

			final ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
			this.swapClassLoader(oldClassLoader);

			try {
				final SchemaExport export = new SchemaExport(config);
				export.setImportFile(ExampleSessionFactory.FAKE_SCRIPT);
				export.create(false, true);
			}
			finally {
				Thread.currentThread().setContextClassLoader(oldClassLoader);
			}
		}
		catch ( final Exception e ) {
			this.logger.fatal("Error while initializing database", e);
		}
	}

	private boolean schemaInitRequired(SessionFactory factory) {
		final Session session = factory.openSession();
		try {
			final Connection connection = session.connection();

			try {
				final Statement statement = connection.createStatement();
				try {
					final ResultSet resultSet = statement.executeQuery("SELECT * from APPLICATION");
					try {
						return ( !resultSet.next() );
					}
					finally {
						resultSet.close();
					}
				}
				finally {
					statement.close();
				}
			}
			catch ( final SQLException e ) {
				return true;
			}
		}
		finally {
			session.close();
		}
	}

	/**
	 * Swapping with a *fake* class loader to trick hibernate
	 *
	 * @param oldClassLoader
	 */
	private void swapClassLoader(ClassLoader oldClassLoader) {
		Thread.currentThread().setContextClassLoader(new ClassLoader() {

			@Override
			public InputStream getResourceAsStream(String name) {
				if ( ExampleSessionFactory.FAKE_SCRIPT.equals(name) ) {
					return new ByteArrayInputStream(ExampleSessionFactory.this.sql.toString().getBytes());
				}

				return super.getResourceAsStream(name);
			}
		});
	}
}

Enjoy your dynamic import.sql…

As you are reading this post, probably

• You do web application development
• You use maven as your your build system
• You like to debug your application right from eclipse (preferably  also using Maven Eclipse Integration )

But,

• you HATE the standard java logging and anything else – commons-logging, log4j, slf4j – will do it for you.

Here’s what you should do…

<build>

...

<plugins>

...

  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>tomcat-maven-plugin</artifactId>
    <version>1.0-beta-1-hc</version>
    <configuration>
      <systemProperties>
        <java.util.logging.manager>org.apache.juli.ClassLoaderLogManager</java.util.logging.manager>
        <log4j.configuration>file://${basedir}/src/main/webapp/WEB-INF/log4j.xml</log4j.configuration>
      </systemProperties>
    </configuration>
    <dependencies>
      <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>juli</artifactId>
        <classifier>log4j</classifier>
        <version>6.0.26</version>
      </dependency>
      <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>juli-adapters</artifactId>
        <version>6.0.26</version>
      </dependency>
      <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.13</version>
      </dependency>
     </dependencies>
   </plugin>

...

  </plugins>

...

</build>

Now, there needs to be done couple of things

• juli-6.0.26-log4j is not published by tomcat project. you need to obtain tomcat juli log4j and install / deploy it to your local / company repository.
• maven-tomcat-plugin has a bug that it sets the systemproperties just too late. you should either build and deploy an interim version of the plugin or check it out from the trunk and stick to the SNAPSHOT version until the plugin releases a new version.

For the second issue I emailed the author of the plugin, Olivier Lamy and asked about a planned release date, as I get an answer, I will publish the date here.

As a separate thing, the plugin has another bug that exposes itself if the application must run as ROOT application in tomcat and either the application or the framework(s) it is based on (struts, urlrewriter, etc) uses server side redirects (internal dispatching). TYhe bug is discussed  here and also the fix for that got main stream.
Enjoy…

According to this post android is picking up market share at an unprecedented pace.

Obviously the graph is on the traffic source rather then number of users or handset sales and at least in my experience, android encourages users to use their device more for the internet, nevertheless it should give the idea. And it is based on the US data, where android powered phones and devices are marketed as much aggressively as iPhone, so for the rest of the world,  iPhone shares should be on the positive side for Apple’s account.

However, what to read from this piece of information is being totally justifying the motivation for Apple – HTC lawsuit, iPhone is loosing a great deal of market share to Android. On the flip side of the coin, despite a big deal of re-work in Windows Mobile 7, Microsoft is far from being a major player in the game.

Another thing I could read from the data is, mobile arena is one of the largest market, where innovation and quality is awarded with immediate market share. While it takes years to change the adopted habits on the desktop computing – even with the netbook market wars, mobile users seem to be have more tendency to switch their choice of operating system. I can also see this as having used 3 different OS’es in the last 7 years – symbian, Windows Mobile, Android…

Being a hardcore Linux and java and eclipse developer, I can hardly wait to have some time to start doing professional stuff on Android.

I have recently fed up with the broken dependencies and potential boot problems after ever every update and decided to give Ubuntu a try – an action that was long awaiting on my to do list.

Although this does not mean I dumped Fedora – as I have been involved with Fedora every since the Fedora Core 1, it is a simple head up and look around.

The reasons for my recent ubuntu interest are

• Ubuntu has been around for a while and quite mature, even one can argue it is more stable then Fedora
• I have recently dived into the Android platform. Android uses the Ubuntu as the base
• I have also interest in intel’s netbook targeted OS – Moblin
• I have been long planning to get accustomed to debian breed linux systems
• If I get knowledgeable on ubuntu, I can convert more Microsoft users to Linux as Ubuntu seems to target the end users and remove the barriers for non-GPL software sources and propriety / copyrighted software
• etc, etc.

For those that are hardcore console users like me, when it comes to maintaining the OS, yum and rpm have always been the best friends. Now there seems to be a need for crash course to adopt apt and dpkg utilities and not surprisingly a simple  googling revealed ubuntu already prepared the info for us.

With the widespread of the internet, today there is many many open source projects. This means competition is now not only in between closed source proprietary projects, but also in between open source projects and closed source proprietary as well amongst the open source projects themselves. This requires projects to adhere a set of standards to stay alive – especially for those in their early incubation phases.

Having been in the OSS World throughout its prime time,  I have a good deal of observations as to how a project endures over time an become a success. ı would like to share this experiences as an executive summary here. Here it goes…

1. Your Project is Your Promise

It is always a good idea to mock up stuff for a developer. Learning by trial is one of the best way to improve one’s self. If you have a sparkling idea, start by writing in down and coding as soon as possible.

Develop your project any time you like. Invite your friends to join. Work / study all the way you like. This is only until you go public and make your statement.

Starting an OSS project is no different then taking on a new job – you make a promise, people will rely on you, so keep it!

2. Have a Clear Mission Statement and Defined Targets for Your project

This is something you should apply not only to your OSS project but almost everything in your life.

“Carpe diem” is a very striking phrase but does not work in professional world.

Define your project’s mission statement and keep it as short as possible. Outline the targets it has and try to satisfy those.

3. Ensure Your Project’s Life

You project is like your child. You should ensure a sustainable life for your project just like you prepare your child for the life. That means plan your time and devotion to your project. If you are not prepared to devote yourself, do not go public – otherwise this will only harm your credibility.

A good idea to find sponsors or work a financial model for your project. Your project needs you, you need time and time is money.

There is a lot of platforms that will provide the basic platform for free of charge. During your projects incubation, using one will save you hosting and other costs, also the tools they provide will give you the most effective distributed agile environment.

4. Have a Good Build System

Have an automatic build system that produces nightly snapshots. As your number contributors increase this will help your project have a better and agile distributed contribution system.
Prepare a “How to Build” page and enable your project to build without a complex build environment on an anonymous user’s system. This will increase anonymous contributions and conversion of anonymous contributors to committers in time.

5. Have a Schedule

OSS community usually follow the latest and the greatest. Thus, having a clear schedule that lists the dates and milestone / release deliverables is key to maintaining the interest from the community. Not to mention, try to adhere your schedule and inform of changes in timeline and / or features as soon as they are known to you.

6. Treat Your Community as Your Clients

A common mistake by OSS projects is sometimes they think they give away something for free or doing a great favour to their user base.

Do not forget, the motivation is “you should think of ‘free’ as in ‘free speech,’ not as in ‘free beer’”. This is as true for yourself as for your community. You DO get something in return, therefore treat your community as your clients.

7. Maintain Your Project

Keep an issue tracking system, an FAQ, a Quick Start Page and forum for the project. And do NOT just create the instruments like these ones just because the platform you are hosting will create them automagically for you. Use it!

You should view all this instruments as your channels to the community. A phone never answered creates nothing but frustration. The same goes for project instruments. Having these channels and actually using them properly will help improve the communication with your community.

Keep your issue tracking system live. Give “human” responses to acknowledge the need, assess the case and engage in early discussion as much possible as you can. It is also good idea to map issues that are confirmed to planned versions and milestones. This way your community knows that their submissions are valuable, and they know when to expect a return for their time and effort for the submission.

Forums are key to extend the community and gain popularity by helping out newbies. Unanswered questions will only make you loose potential new members. As always keeping one happy is 10 times easier to get a new one.

From postings in the forums and irrelevant, extract the common cases and mistakes. Compile an FAQ out of them, make it accessible and refer to it in the forums and issue tickets.

A project may also want to utilize channels like a News Page, a Blog by its contributers and IRC Channel, etc. The same rule applies though, you create the channel, it is your responsibility to keep it live and functional.

8. Try to Understand Your Community

Another common mistake is not paying attention to your community or not trying to understand what community requires.
A good example of that is, the attitude I have seen in some of the bug / enhancement submissions and forum postings. Once every while, we see developers or architects reply with some sort of “This is how it works and cannot change, PERIOD”.
A rather better approach is to try to understand what the change arise from, if it is worth to discuss the issue in detail with the community member(s).
If the request does not make sense, explain in detail and try to convince. An explanation like “Because it is more useful the way it is” is not giving enough details and terminative rather then collaborative.

9. Think Before You Code

It is a very good phrase that “Removing one existing line in the code is better then adding two.”
Adhere the common practises like DRY, Segmentize and Modularize, Use in-code Documentation, etc.
Always bear in mind that some new contributeos join projects and some leave in time. You should also ensure your code is maintainable and not reliant on specific people

10. Collaborate with Other OSS Projects and Encourage Downstream Projects

Do not try to solve all the problems yourself. “Car manufacturers do not produce nails and bolts.” Try to use what’s already available. Collaborate with the projects you are in relation with and help those evolve by identifying the missing bits and parts in them.

Similarly, encourage the projects make use of your projects and projects implementing complementary and extensional features to your projects. This is rather then being a threat another reason for a longer life to your project.

Well, I hope these observations help projects in their incubation as well as the ones enjoying their maturity.

I guess fixing bugs in a project out of reach is one of the most entertaining thing for a husband who doesn’t want to go to bed on Friday night.

So here it goes, I was obsessed with the progress view showing hugely high items. I submitted a bug to Platform/UI team. Then I was deceived with not seeing for a while.

But it turned out to that this is still happening and based on some state – if a job has been started and it never called beginTask. I don’t have so much clue but this boils down to calling computeSize with ‘0′ width hint. Then a bug in the way SWT Link (the sub progress info label of the job info item that displays sub task information and optionally can link to other UI elements ie: console) comes to expose the bug.

SWT Label computes the size with 1px width if the width hint is given as 0. Which wraps all the text in the link down and makes its height huge. But this happens only during the layouting, so the user doesn’t see the word-at-a-line presentation of the link.

In the end, “Changing the 1px hint to Integer.MAX_VALUE fixes the issue” like charm.

“One more bug is fixed” as “one more day is over @ ceylan’s office”

Couple of days ago I wrote the article Is JavaEE overrated?

Thanks to comments, another article arouse from its ashes Here it goes…

If it wasn’t open source I wouldn’t. I am still reluctant to technologies that are in use for 10+ years and closed sourced.

I’ll continue a bit why I didn’t view this as a “big” risk and went ahead.

1) I am not sure exactly but RAP has its roots in 2007 or earlier, [i], RAP [i] is based on Eclipse RCP [ii], I had developed my first RCP application back in 2005 and have had 3 RCP enterprise applications so far (two of them as being desktop client) . And when it comes to developing a Web Application for corporate business (I mean no traditional website looking application), developing it in java helped us use absolutely zero HTML, JS even we could reuse icons, graphs, menus, wizards, etc. available in eclipse. That saved us tremendous amount of time.

2) Eclipse EMF [iii] started in 2002 and powers most of the eclipse based tools and a great companion for Eclipse RCP. Eclipse has so much belief in EMF, so EMF has its own incubation pool called EMFT

3) Most of the Teneo [iv] code is a glue in between the EMF and Hibernate and gets kicked only during hibernate boot. It generates a hbm.xml that gets passed to hibernate. From then on, it only intercepts the collections and so-called EMF term “containment” – which merely couple of hundred lines of code. The upside of using it, you can reuse the EMF model (The whole idea behind EMF – “reusable models”). And when developing the application this implementation boots in sub second in comparison to “Annotated Hibernate Model” which takes about 30 secs to boot with ~100 tables / classes + many-to-many associations. Again a great time saved here too!

4) Eclipse OSGI has been around ever since Eclipse 3.0 released (may require correction). Eclipse as IDE used it way more then any application server and with way more components then an J2EE application server ever can have. Under the hood Equinox OSGI implementation was the power horse of that structure and biggest contributer to OSGI Alliance [v]. It is only recently, that Equinox stepped forward to claim its name.

5) As for the Hibernate and JTreeCache, I think no one argues (at least for hibernate) that these are mature enough.

More over, given the time frame and resources for the project, I think it would have been the bigger risk to go with a conservative approach in this particular instance. One of my benchmarks within the organization showed:

1) This project had 100K lines of which 50K is generated code

2) A highly similar project in terms of customer, criticality and scale had 140K lines of code

3) Our project took 40 man x month of which most spent on E-Signature, integrating with a propriety SOA engine (darn!) and “Data Versioning”. In total project took 7 months with 4 resources (Yeah we did work a lot in the nights and weekends)

4) The counter project spent ~200 man x month and span over 2 years with 4 – 16 resource in variable times. It used hibernate and JSF on a propriety Application server

5) Our application had the better user experience with background UI tasks, multi tasking features (of Eclipse Workbench) and fully generated-on-the-fly client side javascript code – A great Web 2.0 environment. (You can test drive the concept with yoxos) Although to be fair, the counter project was developed in 2006-08 and did not have access to the current technologies then.

In the end of the day all I did was to glue the pieces together… Plus we buttered up with maven, init scripts, issue management, ci, and rpm releases but that has nothing to with the osgi and can go together with Java(2)EE but worth mentioning…

[i] http://ondemand.yoxos.com/geteclipse/start http://www.eclipse.org/rap/

[ii] http://wiki.eclipse.org/index.php/Rich_Client_Platform

[iii] http://www.eclipse.org/emf

[iv] http://www.eclipse.org/emft/projects/teneo

[v] http://www.osgi.org

Update sites in eclipse projects is a great features. One of the big reasons for “web applications” (By that I mean applications running in browser and exclude traditional web sites) was the distrubition and update problem.Eclipse with its large ecosystem found itself need to solve this problem, a recently got better with p2 implementation.

However, one of the problems with the easy-to-use update site projects in eclipse is it is not obvious how to include your source code in the features you deploy.

Well, a common way of implementation of this is as follows and you may want to browse or check out using SVN the EMF Builder project to see it in action [1]

* Create your plugin project, name it say com.example.myproject.plugin

* Create a feature project which refers to the plugin and plugin and feature dependencies it requires, name it com.example.myproject.feature

* Create ANOTHER feature name it com.example.myproject.sdkfeature

* Create three folders in the root of com.example.myproject.sdkfeature: rootfiles, sourceTemplateFeature, sourceTemplatePlugin. These will be the templates for our source plugin and feature projects

* In the build.properties of the have the following:

bin.includes = feature.xml,\
feature.properties,\
modeling32.png,\
epl-v10.html,\
license.html,\
about.html,\
about.ini,\
about.mappings,\
about.properties

src.includes = epl-v10.html,\
license.html

root=rootfiles

generate.feature@com.example.myproject.source=com.example.myproject.feature

This will instruct update site builder to create a source plugin com.example.myproject.source which includes the sources for plugins within com.example.myproject.feature

You need not add plugins to the sdk feature. Just add the feature com.example.myproject.feature and virtual com.example.myproject.source feature to the “Included Features” section of the sdk feature.

Add the sdk feature to your update site. Ideally update site included two features together, com.example.myproject.sdkfeature and com.example.myproject.feature, so your users can choose to install binary or source + binary versions.

Build and deploy the update site, test it from eclipse you should be able to see two featıres,.

[1] http://emf-ebm.svn.sourceforge.net/svnroot/emf-ebm/

In a previous assignment we had a project more like an intranet application where you manage document, make applications (which flow through a complex 400+ step BPM), integration with a SOA engine, task, inbox, etc… It was a large government project with 500 daily users.

We chose the RAP [RCP], Databinding, EMF, Teneo, hibernate, JTrecache, Equinox[OSGI] project stack. We also have written a simple editor to manipulate EMF model.

I must admit I enjoyed defining my models in ecore. With the help of teneo my DAO consisted only ~100 lines. Since the application security (this is including down to input element levels with hidden/read/write granularity) was so tight we also kept the security definitions in the ecore model.

We kept the database schema definitions along with the ecore classes, which helped BI developers and DB admins to get updates momentarily (In the early phase of the project there were weekly deployments).

I think one of the problems with java world is it has the J2EE definition. 90% times you make a project, you choose the Application server, JPA, Web model etc for the project. But people believe “If it is a commercial / corporate product it’s gotta be J2EE compliant”, which is a big bold and IMHO unnecessary binding. Most of the time, you do not WORE! Not to mention there is the saying “Write Once Debug Everywhere”.

Lately application server vendors started adopting OSGI and we’ll see where this will go. But to be honest (this might require a correction) without using equinox, you cannot use much of the eclipse technologies where  the base plugins require definitions via extension points. e4 with the new dependency injection stuff may make this comment deprecated. But with the  more and on-the-target adoption of OSGI, we’ll see more eclipse technologies used outside RCP and IDE domain.

On the project I mentioned, people were like ‘Are you crazy you are taking way more risks,  how are you gonna get support’, well, we used the SOA engine and DB of one of the largest provider provider, we have a support ticket still open for 6 months, where I had over 20 interactions with RAP, Teneo, EMF team all resolved within hours to days. Imagine if we were using the application server from that vendor.

In the end, the project was a big success and a breakthrough not in the country but at the global level. So I think developing enterprise application doesn’t mean you gotta go JavaEE. Putting together your own OSGI stack is much better. Plus while developing, you will get the joy of restarting the application in a matter of seconds rather then in minutes in comparison to application servers.

The EMF Builder 0.1-beta has been released and I wish everyone to install and give it a test drive.

Update Site:
http://emf-ebm.svn.sourceforge.net/svnroot/emf-ebm/update/

Project Proposal:
http://ebm.batoo.org

Upon installation, right-clicking on the project and Configure -> Add EMF Nature will enable the functionality. In case you experience problems with it you can turn off the nature the same way you enable it.

It should not be dangerous for your source as it uses the EMF and GMF code generation framework. The worst case scenario it will not trigger builds.

Here are the highlights:
* It supports full list of EMF resources by file extension
* It supports transitive dependencies upwards and downwards
- Downwards, if there is an error on a resource, the resources dependent
on this one will be suspended
- Upwards, resources watch for changes in the dependencies and rebuild
when necessary
* It detects the underlying EMF version and regenerates on a change
detection
* Dependency state is preserved across eclipse sessions
* Takes advantage of the Jobs Framework as much as possible with detailed
progress reporting through progress view.
* It provides three extension points
- An extension point to register validators, built in EMF Validator is
registered with this extension
- An extension point to register generators, built in EMF Generator is
registered with this extension. And also a complementary GMF generator uses
this extension points
- An extension point to register content types with the infrastructure,
GMF Gen content type is registered using this extension point
* Full error / warning reporting via “Problems View” marker support
* Quick fix support
* Trace support (For bug reports I would appreciate trace turned on)