Archive for December, 2012

Guide: c3p0 – JDBC3 Connection and Statement Pooling

After I uploaded my JavaEE course project to Openshift hosting service as you
could do using the Guide: Introduction to Openshift hosting Apache Tomcat, I thought
that my work with this project is done. But strangely for me I started to encounter
database connectivity issues. I done a little research and realized that the reason for
those problems is the default MySQL configuration for closing inactive connections to
the database. MySQL automatically closes any inactive connections to the database
after the default 8 hours. Unfortunately Hibernate ins’t aware of that and still thinks
that the connection is open when trying access the database to perform a query.
Of course Hibernate will fail to perform that task and we will be given the following exception:

[org.hibernate.exception.JDBCConnectionException: could not execute query] with root cause Can not read response from server. Expected to read 4 bytes, read 0 bytes before connection was unexpectedly lost.

To fix this issue as it’s done in production environments it is important to implement
some sort of connection pool mechanism that will always keep open shared connections
to the database for all application users. Here I’m going to show you how to implement the
c3p0 – JDBC3 Connection and Statement Pooling mechanism in your project with
Hibernate already implemented:

1. So clearly the first thing that needs to be done is to download the c3p0 project files.
Use the following link to download the latest version from Source-forge.

2. Extract the files from the zip archive and copy the c3p0-0.9.2-pre7.jar
and mchange-commons-java- to the lib folder of your project.

3. Edit your hibernate.cfg.xml and add the following infomation under the
<session-factory> hive:

<!-- important to specify c3p0 as your connection provider -->
<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>

<!-- configuration for connection pool via c3p0 -->
<property name="c3p0.min_size">3</property>
<property name="c3p0.max_size">20</property>
<property name="c3p0.acquire_increment">1</property>
<property name="c3p0.max_statements">50</property>
<property name="c3p0.timeout">14400</property>
<property name="c3p0.idle_test_period">3600</property>

It is really important to specify the “connection.provider_class” property as:
org.hibernate.connection.C3P0ConnectionProvider or hibernate will continue using it’s
own default mechanism. Other properties may be customized to your liking.
Eventually your hibernate configuration file should look like this one:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        <!-- default hibernate connection settings -->
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost:3306/database</property>
		<property name="connection.username">user</property>
		<property name="connection.password">password</property>
		<!-- for MySQL users specify the following dialect -->
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
		<property name="show_sql">true</property>
		<property name="">update</property>
		<!-- inmportant to specify c3p0 as your connection provider -->
		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		<!-- configuration for connection pool via c3p0 -->
		<property name="c3p0.min_size">3</property>
		<property name="c3p0.max_size">20</property>
		<property name="c3p0.acquire_increment">1</property>
		<property name="c3p0.max_statements">50</property>
		<property name="c3p0.timeout">14400</property>
		<property name="c3p0.idle_test_period">3600</property>
		<!-- end of configuration -->
		<mapping class="com.eadesign.hibernate.CouponDetails"/>
		<mapping class="com.eadesign.hibernate.Company"/>
		<mapping class="com.eadesign.dto.User"/>
		<mapping class="com.eadesign.dto.Administrator"/>
		<mapping class="com.eadesign.hibernate.Feedback"/>	

And that’s it, now you have connection pool in your project.

more information can be found in the c3p0 manual.
As this Appendix C: Hibernate-specific notes:

Appendix C-Hibernate of c3p0

December 19, 2012Emil Adjiev 1 Comment »
FILED UNDER :Guide , Guide - Java Development

Guide: WordPress hosting on OpenShift

Actually in my opinion this is one of the simplest ways to get your WordPress blog/site
up and running in no time. in just few simple commands you have a Blog in the air that
you can customize and edit to you liking. I am counting that you already have created your
own OpenShift account and installed the rhc Client Tools. If not please head to my
Guide: Introduction to Openshift hosting Apache Tomcat post and follow the first two
paragraphs to open the account and install the tools. I would recommend to read all of it
as it holds great information regarding tools that will simplify your work with OpenShift.

Now you are ready to create our own WordPress application container on OpenShift.
Open your command prompt and head to the location were you want your git repository
for this project to be created and enter the following command:

rhc app create -a <name for your container> -t php-5.3

Name your application container as you wish. This name will be part of the URL for accessing your application.
So now we allocated resources to ourselves in Red Hut’s cloud with php 5.3 application
already installed. WordPress needs a database to store it’s data and can’t live without
it so we will add MySQL database to this configuration using the next command:

rhc cartridge add -a <name of your container> -c mysql-5.1

And finally I always add the phpMyAdmin application to make it easier on me to manage my
databases. To do that run the following command:

rhc cartridge add -a <name of your container> -c phpmyadmin-3.4

Save your database credentials produced at the end of this process.

Now we are ready to install WordPress. There are two ways you can do that:

1. The first and the easy way to get a WordPress installation is to pull it from a git repository.
Head to your application folder using the next command:

cd <name of your container>

Now set the remote git repository to pull it’s stream from it:

git remote add upstream -m master git://

Pull the stream/content:

git pull -s recursive -X theirs upstream master

And push it to your repository on the cloud:

git push

To access your WordPress application use the default credentials:

User name: admin
Password: OpenShiftAdmin

The problem is that the version of WordPress now hosted on this repository is 3.4 and there
is a new 3.5 WordPress installation available. You could upgrade your WordPress version
using it’s Dashboard interface, but now you will have 2 different versions of WordPress
on your local git repository (3.4) and the clouded one (3.5). I will explain how to fix this
problem in the update section.

2. Alternatively you could push you own WordPress installation to your cloud repository.
Head to and download the latest version of WordPress.
Copy the downloaded content to the php folder in your local repository and open the
command prompt. Head to your local git repository folder and enter the following command:

git add .

For letting git know of all the changes that were made to that folder, then:

git commit -m "added wordpress3.5"

Committing the changes to the local repository. And finally Pushing the changes to the cloud:

git push

And that’s it, now you can access your new WordPress application using the URL
you are provided on OpenShift and start customize it.

Updating your local repositry with the changes made by WordPress in the cloud:

When you will update you WordPress installation in the future or maybe you would want to
change the looks of your blog/site by adding a sleek Theme or maybe a Widget and you’ll do
that using the Dashboard interface, you would have to update your local repository with
those changes. In that case what you need to do is to take a snapshot of your machine on
OpenShift using the next command:

rhc snapshot save -a <name of your container>

this will download a <name of your container>.tar.gz to you local git repository
containing a snapshot of your files from the clouded repository. Extract the files to a folder
with the same name and head to:
<name of your container>\<your OpenShift ID>\app-root\repo\
Copy the content of this folder to your local git repository folder and commit the changes
using the following commands:

git add .
git commit -m "wordpress updated"
git push

That way the files on your local repository will be identical to those in the cloud.

December 15, 2012Emil Adjiev No Comments »
FILED UNDER :Guide , Guide – Web Development

Guide: Introduction to Openshift hosting Apache Tomcat

To present my Java EE course project in this blog I had to find another
Apache Tomcat hosting service since the one we got during education was
not responding anymore. That’s how my search for a free Apache Tomcat
hosting service started. I contacted with my hosting service where i host
this blog and I was quickly explained that this kind of service is not
supported there. Next i went to the web (Goggled) to search for such free
service just to find out that there are not that many of them at all.
And then I saw that Red Hat offering Apache Tomcat service and much more
with their OpenShift PaaS – Platform as a Service. They basically give you
a platform (clouded resources) to deploy your applications and this platform
supports Node.js, Ruby, Python, PHP, Perl, and Java technologies and much more.

So how is it done?
1. The first thing is to go to and create an account.
Once you have created an account you can publish 3 application for free.
During the creation of your account you will have to specify you Namespace
that latter on will be used for your application URL’s.

2. Install the OpenShift client tools. For that you need to install Git for Windows
and a Ruby and configure them. This is explained in the following link.
During the configurations of Git you will create an ssh key for connecting
to your repository on Red Hat.

3. Now that you installed the client tools you are ready to create your first
application container on OpenShift. Actually this can be done using their web
interface but it’s faster to do that with the command line. To create your
application container with Apache Tomcat already installed you need to run to
following commands in the command prompt:

rhc app create -a tomcat -t diy-0.1

this will create for you your DIY (do it yourself) application container on
Red Hat’s servers with the name “tomcat” and a local Git repository in your
current location at the command prompt with the same name. now all you need
to do is to edit your local repository and to push changed to the server
uisng git.

Enter your repository folder by entering:

cd tomcat

and then enter the following commands:

1.git remote add upstream -m master git://
2.git pull -s recursive -X theirs upstream master
3.git push

what we are doing here is configuring a remote upstream and we pull it’s content from it
to our local git repository. finally we push this changes to our own application container.
at the end of this process we will have a DIY application with Apache Tomcat 7 installed.

4. Now we need to connect to our application container to copy there our application files.
There are 3 way to do that: we can copy the files to our local git repository and push the
changes to the server, we can use an SSH terminal (like PUTTY) and edit the files using
commands from the command line or we can use an SSH based FTP tool (like WinSCP)
to manage files as you would do in a commander interface.

you can download PUTTY from here. You should download the zipped file for all PUTTY package.
you can download WinSCP from here.

putting your project into the webapps folder of your local application repository and pushing
it to the server will put your files in the following location:

/var/lib/openshift/<your openshift userID>/app-root/

and this is not the right webapps folder for the installed Apache Tomcat.
That is the reason I prefer to use the WinSCP application. So lets open WinSCP and
the first window you will receive is the WinSCP Login window:

enter the following information:

  1. Your full application container URL – you can get it from OpenShift.
  2. Your Username – again you can find it on your application page on OpenShift under the “GIT REPOSITORY” section.
  3. Your OpenShift password.
  4. You have to supply your ssh key, you can create it using puttygen.exe application that you can download from the PUTTY link. Open puttygen.exe:

  1. Click the “Load” button and go to your C:\Users\<your windows username>\.ssh folder. Chose the id_rsa file (without extension) and press Open. you will be notified that this is a security key.
  2. Click the “Save private key” button to save a new private key (.ppk) file.

5. Now you can supply your security key and connect via WinSCP to your machine on Openshift.
When you connected you will receive a commander window. The right pane connected to
your OpenShift repository at the following location:

/var/lib/openshift/<your openshift userID>/

Head to:

/var/lib/openshift/<your openshift userID>/app-root/

and copy your project files here.
Head to:

/var/lib/openshift/<your openshift userID>/app-root/

and copy your project resource files (your Jars necessary for the project).

6. Finally open command prompt again and run:

rhc app restart tomcat

to restart your container and let the changes take affect. now you can access you project
using the application URL you can get on OpenShift.

December 11, 2012Emil Adjiev 2 Comments »
FILED UNDER :Guide , Guide - Java Development

Java EE Course Project: Location based Coupons

In my Java EE course we had to make a combined server and client applications.
I have decided to created a web location based coupons application.
While for the server I have created an MVC based application that allowed me as
an administrator to add, remove and change the coupons. For that i used Servelts,
JSPs and Hibernate technologies, for the client application i developed a small web
based application that allowed the user to display a Google map with only the relevant
coupons to the user’s specified distance from his current location and this was
achieved using HTML 5, jQuery Mobile and Ajax. The information passed from the server
to the client by an XML file. The main goal of this project was to learn the server/client
programming so both the server and the client applications are fairly simple.

Client application screenshots:


you can enter the client application using the next link.

the server application is a very simple one as well and it’s practically consists only
from forms for inserting, removing and editing data in the databases. All coupons in the
application are fabricated and created only for the sake of practice.

December 9, 2012Emil Adjiev No Comments »

C++ Course Project: Painter Application

This was one of my first programming projects during my education.
We were required to build a Painter application using C++ while the
main goal was to learn and practice Object Oriented programming.
the application is fairly simple. It allows you to create your painting
and save it into a file, you can also use the Redo and Undo options.
Nevertheless this application served it’s purpose greatly at the time
and i have learned a lot from creating it.

here a screenshot of the application:

and you can donwload the executable from here.

December 3, 2012Emil Adjiev No Comments »

Java SE Course Project: Client Application for Google Calendar

In this project the main goal was to get to know Google’s API.
Then we had to create windows client application that allows
the user to connect to his Google Calendar account and to perform
actions like: adding, changing and removing appointments from the
calendar. Off-curse the application was created using Java, for
the user interface i used an Eclipse plugin called Jigloo.
The application interface is plain and simple as you can see:

You can download the application from here.

December 2, 2012Emil Adjiev No Comments »

Android Course Project: YAMBA

During my Android course i created a client application for a Twitter based service.
It’s was created with a great deal of help from Marakana classes. The name
of this application is: YAMBA, that stands for “Yet another micro bloging application”
I have added some more features and upgraded the application even further.
I learned a lot from creating this application and used all the main Android building
blocks as: Services, Threads, Content Providers, Activities, Intents. I have even created
a Widget for this application that will always show the last twitte in the service.

you can download the application here


you can use the application with the default credentials:
User: student
Password: password

Or you can head to and create your own user.

December 1, 2012Emil Adjiev No Comments »


As i already mentioned in the ‘About Me’ page I created this blog to present
my existing and future projects and to find my next career challenge.
During the next few weeks i will update this blog with my already existing
projects i have worked on during my education and before.
of course future projects will be presented here as well.
I hope you’ll enjoy using them.

Little Test

December 1, 2012Emil Adjiev No Comments »
FILED UNDER :Discussion