Ramki Java Blog

Tomcat Clustering Series Part 5 : NginX as Load Balancer

noreply@blogger.com (Rama krishnnan E P) — Mon, 28 Jan 2013 15:06:00 +0000

Hi this is my fifth part of the Tomcat Clustering Series. In this post we are going to discuss how to replace Apache httpd load balancer to Nginx as a load balancer. [Check the video below for better understanding]

Hi i finished Tomcat Clustering Series. In these series we have 2 big setups needed for Tomcat Clustering

Setup and configure the Load Balancer
Configure the Session Replication in Tomcat.

In first setup, we configure the Load Balancer using Apache httpd web server. Its open source and widely used.

Second setup is session replication in Tomcat through modify/add <cluster> tag in server.xml file. These tomcat instance may run on single machine or different machine.

In our Tomcat Clustering Series, the big part is configure the Load balancer (Apache httpd web server). Because there are lots of steps are involved

Install the Apache httpd web server from either source or repo
Compile and install the mod_jk connector
Create the workers.properties file (add tomcat IP and ajp port information )
Configure into httpd.conf file (Add mod_jk related settings)

these setups are take more time and very difficult to debug.

Is there is any alternative to load balancer?

Yes, Nginx its emerging web server. this post we are going to discuss how to setup nginx as a load balancer in our tomcat cluster.

What is Nginx?

Nginx is open source and alternative to Apache httpd web server. Its provide more performance and little memory foot print.

Install Nginx

we can install nginx through either repository (apt-get,yum) or from source. here i m build nginx from source from here. then extract the compressed file.

./configure --help

above command shows possible command line options available for compile

for install use this command

./configure --prefix=/home/ramki/nginx --with-http_ssl_module

here

--prefix used to specify where nginx server want to install, here i m using my home folder (like /usr/local/nginx)

--with-http_ssl_module here i specified install SSL module (https), its not necessary. If we want secure webpage then this module is needed.

then compile the source

make

install the nginx based on our configuration

sudo make install

now installation is done, To start the nginx,

cd /home/ramki/nginx/sbin

sudo ./nginx

now open browser and go to http://localhost to get nginx default page.

To stop the nginx, we need to pass stop signal via -s option

sudo ./nginx -s stop

Configure as a Load Balancer

Nginx configurations are stored in nginx.con file in conf/ folder. We need to perform 2 steps to make nginx as load balancer.

First define Upstream block in nginx.conf file

Upstream block provides simple load-balancing across upstream (backend) servers. In upstream block have unique name (here tomcatcluster), later we need to point out from other block.

upstream tomcatcluster {

server 127.0.0.1:8181;

server 127.0.0.1:8282;

server 127.0.0.1:8383;

}

here we define the back-end servers (Tomcat instances) via server directive.

In each server directive we mention IP address of server and HTTP port number(Not AJP port number).

Second forward (proxy) the request to back-end servers

This step is forward the request to upstream blocks, where we define the back end servers.

location / {

proxy_pass http://tomcatcluster;

}

here if location / is already present, then remove and add this new one.

here proxy_pass directive, proxifier(forward) the requests to upstream servers. here tomcatcluster is name of the upstream block and we used http protocol to forward the request.

that's it. Load balancer is ready.

now start the tomcat instances based on my previous post (session replication). then start nginx.

now access http://localhost.

now nginx forward the request in round robin fashion to back-end servers. all servers have the session, so it can able to process the request

This is same as non-sticky session method we used in my previous posts.

If we want sticky session, then nginx directly not provide, but some 3rd party patches are available. but nginx provide ip_hash directive. Its forward all request from single IP to same tomcat like sticky session. But sticky session works based on cookie (session). but ip_hash is based on IP address of client.

If u want to configure ip_hash, then modify the upstream block, add ip_hash

upstream tomcatcluster {

ip_hash;

server 127.0.0.1:8181;

server 127.0.0.1:8282;

server 127.0.0.1:8383;

}

just restart the server, u feel like sticky session concept.

when we compare the Nginx to Apache httpd web server, nginx is provide simple configuration, and can handle huge amount of traffic, consume little memory foot print and its take little CPU load.

search Nginx vs Apache we get some amazing benchmark results.

Screen Cast :

Tomcat Clustering Series Part 4 : Session Replication using Backup Manager

noreply@blogger.com (Rama krishnnan E P) — Wed, 05 Dec 2012 13:54:00 +0000

Hi this is my fourth part of the Tomcat Clustering Series. In this post we are going to discuss the how to setup session replication using Backup Manager in tomcat clustering environment. Session replication makes High availability and full fail-over capability to our clustering environment.[Check the video below for better understanding]

Its continuation of the last post (session replication using Delta Manager). In delta manager each tomcat instance need to replicate the session information to all other tomcat instances. Its take more time and replication if our cluster size is increased. so there is alternative manager is there. Its Backup Manager.

Backup Manager is replicate the copy of session data to exactly one other tomcat instances. This big difference between both managers. here which tomcat creates that is primary copy of the session. and another tomcat whose hold the replicate session is backup copy. If any one of the tomcat is down. back up tomcat serve the session. Its achieve the fail over capability.

The setup process of backup manager is same as Delta manager. except we need to mention the Manager as BacupManager (org.apache.catalina.ha.session.DeltaManager) inside <Cluster> element.

Suppose we have 3 tomcat instances like previous post. and i configured into backup manager.

now user try access the page. User request comes to load balancer, and load balancer redirect the rquest to suppose tomcat1. Now tomcat one create the session, now tomcat1 is responsible to replicate exactly one copy to any one of the tomcat. so tomcat1 picks any tomcat which is part of the cluster (multicast). here tomcat1 picks tomcat3 as a backup. so tomcat3 hold the backup copy of the session.

we are run the load balancer in sticky session mode. so all further request from that particular user is redirect to tomcat1 only. all modification in tomcat1 is replicate to tomcat3.

now tomcat1 is crashed/shutdown for some reason

now same user try to access the page. this time load balancer try to redirect to tomcat1. but tomcat1 is down. so load-balancer pick one tomcat from the remaining tomcats. here interestingly 2 case are there.

Case 1:

Suppose Load balancer pick the tomcat3 then tomcat3 receive the request and tomcat3 itself hold the backup copy of the session. so tomcat3 make that session as primary copy and tomcat3 pick any one tomcat as backup copy. so here remaining only one tomcat is there. so tomcat3 replicate the session to tomcat2. so now tomcat3 hold primary copy and tomcat2 hold the backup copy. now tomcat3 give the response to user. all further request is handled by tomcat3 (sticky session).

case 2:

Suppose Load balancer pick the tomcat2 then tomcat2 receive the request and tomcat2 don't have the session. so tomcat2 session manager (Backup Manager) ask to all other tomcat manager "hi anybody hold the session for this user (based on session id [cookie])". Actually tomcat3 have the backup session. so tomcat3 inform to tomcat2. and replicate the session to tomcat2. now tomcat2 make that session as primary copy and tomcat3 whose already have copy of session as remains as a backup copy of that session. so now tomcat2 hold primary copy and tomcat3 hold the backup copy. now tomcat2 give the response to user. all further request is handled by tomcat2 (sticky session).

so in either case our session is replicate and maintained by backup manager. Its good for large cluster.
check the video below

check my configuration in my github repo or get as ZIP file

Note:

Load balancer also faces single point failure. to resolve this we need to put another load balancer with public address and update the new IP to DNS server with same URL. so our URL like example.com query resolves the 2 IP address for 2 load balancer.

How its work:-
-> If browser want to access http://example.com then it first ask DNS server.
-> DNS server gives 2 IP address to browser
-> Browser take the first IP address and try to connect.
-> If in the case that server is failed to respond then browser side make timeout
-> then browser contact second IP address, now second load balancer is works fine.

This kind of adding more load balancer makes to our website more scalable and reliable in case of tragedy.

check in ur terminal

> nslookup google.com

its gives 11 IP address. these all are google load balancer's located in various geographic locations

Another thing this DNS servers not return same order of IP list to browser. each an every time its rotate(round robin) the IP list. so in 2 different machine ask google.com get different order of IP list. so these 2 differnt machine connect different google load balancer. so here DNS server also play little role for distribute the requests(loads).

to verify use same command twice. and verify the IP order.

Screen Cast:

Tomcat Clustering Series Part 3 : Session Replication

noreply@blogger.com (Rama krishnnan E P) — Tue, 20 Nov 2012 06:28:00 +0000

Hi this is my third part of the Tomcat Clustering Series. In this post we are going to discuss the how to setup session replication in tomcat clustering environment. Session replication makes High availability and full fail-over capability to our clustering environment.[Check the video below for better understanding]

In my previous post we discussed about setup simple load balancer and how to make session affinity concepts.

How to setup Session Replication in tomcat
before going to session replication we need to understand 2 important concepts

Multicast
Session Manager in Tomcat

Multicast

Multicast is To transmit a single message to a select group of recipients. here multicast used by tomcat cluster to identify the instances those part of cluster.

There is 2 types of cluster

Static Tomcat Cluster
Dynamic Tomcat Cluster

In static cluster there is no need multicast, because each tomcat we statically defined/configured the other instances. But dynamic Cluster we are not defined anything. so each tomcat in that cluster some how to identify the other tomcat instances.

so here multicast concepts is used. each and every tomcat first joining to single multicast group. and send the heartbeat signals in periodic interval. so other tomcat instances received these signal and add the member to the cluster.

Session Manager in Tomcat

Session Manager is used to create and manage the session behalf the application. In Servlet Specification request.getSession(); line is mention that container (tomcat) is responsible for create the session. here tomcat use the Session Manager for this purpose.

there is 4 types of Session Manager

Standard Manager
Persistent Manager
Delta Manager
Backup Manager

Standard Manager

Its is the default manager used by tomcat. Even though we are not mention in our web application tomcat use this manager for managing our session. If u want to customize the this standard manager then add <Manager> tag in context.xml file.

<Manager className=“org.apache.catalina.session.StandardManager” />

here org.apache.catalina.session.StandardManager is fully qualified class name of the Standard Manager.

Persistent Manger

This mnager is to sote the session information into persistent place after some interval. here two types of store is available.

File Store
JDBC Store

File Store helps to store all session information in separate files in underlying file system (local HDD or shared file-system like NFS,..)

JDBC Store helps to store the session information to relational database.

so using the Persistent Manager we can achieve the tomcat cluster. but its not swapped out in real time. its pushes the information after certain interval. so if anything badly happen(crash) before that interval then in-memory session data is gone.

Delta Manger

In this post we are going to use this manager. Its replicate the session to all other instances. so this manager usually used clustered environment. but not good for large cluster.

Backup Manager

this manager usually used clustered environment. Its like delta manger. but it will replicate to exactly one other instance(backup instance). Its acted like one instance is Primary and another instance as backup

Steps to make Session Replication in Tomcat Clustering

here i will continue from exactly where i left in last session affinity post. so check that post and make sure jumRoute all are set properly. so steps are

Enable Multicast routing
Add <Cluster> Entries in conf/server.xml file for all instances.
Enable the Web Application as distributable

1. Enable Multicast routing

In Linux Environment most of the system kernel is capable to process the multicast address. but we need to add route entry in kernel routing table.

sudo route add -net 224.0.0.0 netmask 240.0.0.0 dev eth0

here eth0 is my Ethernet interface. so change according to your interface

In multicast address is belong to Class D address Range (224.0.0.0 to 239.255.255.255). so we inform to kernel if any one access these address then it goes through eth0 interface.

2. Add <Cluster> Entries in conf/server.xml file for all instances.

This very important part for tomcat clustering. We need to Add <Cluster> tag in conf/server.xml file in all tomcat instances.

<Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>

we can add this <Cluster> tag in either inside the<Engine> tag or <Host> tag.

here SimpleTcpCluster is Tomcat Cluster implementation

This tag is looks like simple but its has many inner tags. if we omitted then its takes the default values. if we want do any cutomization (like change multicat address, receving address port) we need to use complete <Cluster> tag

this is complete <Cluster>

<Manager className="org.apache.catalina.ha.session.DeltaManager"

expireSessionsOnShutdown="false"

notifyListenersOnReplication="true"/>

<Membership className="org.apache.catalina.tribes.membership.McastService"

address="228.0.0.4"

port="45564"

frequency="500"

dropTime="3000"/>

</Sender>

<Receiver className="org.apache.catalina.tribes.transport.nio.NioReceiver"

address="auto"

port="4000"

autoBind="100"

selectorTimeout="5000"

maxThreads="6"/>

<Interceptor

className="org.apache.catalina.tribes.group.interceptors.TcpFailureDetector"/>

<Interceptor

className="org.apache.catalina.tribes.group.interceptors.MessageDispatch15Interceptor"/>

</Channel>

<Valve className="org.apache.catalina.ha.tcp.ReplicationValve" filter=""/>

<Valve className="org.apache.catalina.ha.session.JvmRouteBinderValve"/>

<ClusterListener className="org.apache.catalina.ha.session.JvmRouteSessionIDBinderListener"/>

<ClusterListener className="org.apache.catalina.ha.session.ClusterSessionListener"/>

</Cluster>

Check my sample conf/server.xml file (for reference)

here most of the code are boiler plate code. just copy and paste. if we need we can customize. for example we can change the multicat address and port number.

<Manager className="org.apache.catalina.ha.session.DeltaManager"/>

here Manager tag define the delta manager. Delta manager means replicate to all instances.

<Channel className="org.apache.catalina.tribes.group.GroupChannel">
Tomcat Clustering use the Apache Tribes communication framework. This group commnication framework is responsible for dynamic membership (using multicast) , send and receive the session delta information using uni-cast (normal TCP connection).

<Membership className="org.apache.catalina.tribes.membership.McastService"
address="228.0.0.4"
port="45564"
frequency="500"
dropTime="3000"/>
This is Membership definition. here address is multicast address. we can pick any address from Class D address range (224.0.0.0 to 239.255.255.255)and any port number.

Each and every tomcat send the heart beat signal to multicast address in periodic (frequency) interval. all other tomcat whose joined the multicast address they can receive these signals and add the membership to the cluster. if heat beat signal is not revive some particular interval (dropTime) from any one of the tomcat, then we need to consider that tomcat is failed.

Note:-
All tomcat instances which is part of the clustering, should have same multicast address and port number.

<Sender className="org.apache.catalina.tribes.transport.ReplicationTransmitter">
<Transport className="org.apache.catalina.tribes.transport.nio.PooledParallelSender"/>
</Sender>
here sender use the PooledParallelSender have pooled connections to use the send the session information concurrently. so its speedup the session replication process.

<Receiver className="org.apache.catalina.tribes.transport.nio.NioReceiver"
address="auto"
port="4000"
autoBind="100"
selectorTimeout="5000"
maxThreads="6"/>
here we define which port Receiver can bind and used for receiving the session replicate information. here two properties are important. address and port. here address is ur system IP address and port is any unused port. here address="auto" its automatically pick the system IP address.

we have some interceptor
TcpFailureDetector -Its ensure that instance are dead. In some case multicast messages are delayed, all tomcat instances are think about that tomcat is dead. but this interceptor to make tcp unicast to failed tomcat and ensure that instances is actually failed or not

another important listener is JvmRouteSessionIDBinderListener, we talk about later

3. Enable the Web Application as distributable

We need to make the our web application distribuable. its simple add <distributable/> tag in web.xml file. In according to servlet specification <distributable/> tag in web.xml mention that any container to consider this application can work in distributed environment.

Note:
All session in our web application must me serializable.

Do these steps to all tomcat instances and start the tomcat and httpd server. check my configuration in my github repo or get as ZIP

This is my configuration. all 3 tomcat instances are configured in delta manager and i deployed the distributed web application. all tomcat use the multicast to maintain the membership.

now client make the request and first tomcat process and create the session, then looks like this

then tomcat 1 is responsible to replicate the session using Apache tribes group communication framework to replicate the session to all instances.

now all tomcat instance have exact copy of the session. so if tomcat 1 crashed or shutdown, then any other tomcat still can process the request [see the video below]

We used session affinity like previous post. based on that cookie id contain the tomcat name (worker name). so when first tomcat1 return the session id end with tomcat1. but when tomcat 1 is failed and tomcat 2 take the responsible for all further request. but session id still contain the tomcat1. so its makes the load balancer difficult. because tomcat1 is down. and load balancer pick any other tomcat. but actually tomcat2 takes the responsible. so we need to reflect these changes in session id.
JvmRouteSessionIDBinderListener take care to change the client session id to tomcat2 when failure is occurred so load balancer redirect to tomcat2 without confusing.

Check the git hub for all configuration files and tomcat clustering setup is available. or u can download as ZIP

Reference:

Apache Tomcat Cluster Documentation

Screen Cast:

Tomcat Clustering Series Part 2 : Session Affinity Load Balancer

noreply@blogger.com (Rama krishnnan E P) — Tue, 30 Oct 2012 08:48:00 +0000

Hi this second part of the Tomcat Clustering Series. In my first part we discuss about how to setup simple load balancer. and we seen how load balancer distribute the request to tomcat instance in round robin fashion. [Check the video below for better understanding]

In this post we discuss about what is the problem is occur in simple load balancer when we introduce sessions in our web application. and we will see how to resolve this issue.

Its continuation of my first part of this series. so kindly go read my first part then continue here.

How Session works in Servlet/Tomcat?
Before going into problem, let see the session management in Tomcat.
If any if the page/servlet create the session then Tomcat create the Session Object and attached into group of session (HashMap kind structure) and that session can identify using session-id, its just random number generated through any one of the hash algorithm. then respond to client with cookie header field. That cookie header field are key value pair. so tomcat create jsessioid is the key and random session-id is the value.

Once response reached to client (Web Browser) its update the cookie value. If already exist, then its overrides the cookie value. Then all further communication browser send the cookie attached with request to that server.

HTTP is stateless protocol. so server can't find the client session usual way. so server reads the header of the request and extract the cookie value and server got the Random session-id. then it search through group of session maintained by the tomcat. (It usually hash-map). then tomcat got perfect Session of that particular client (Web Browser).

If client cookie value doesn't match with group of sessions then tomcat create the completely new session and send the new cookie to browser. then browser update it.

this index.jsp code to deploy all tomcat instances

<%@page import="java.util.ArrayList"%>
<%@page import="java.util.Date"%>

<%@page import="java.util.List"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>


    
        
        JSP Page
    
    

        Instance 1 


        
       
        

        
         

        Session Id : <%=request.getSession().getId()%> 

        Is it New Session : <%=request.getSession().isNew()%>

        Session Creation Date : <%=new Date(request.getSession().getCreationTime())%>

        Session Access Date : <%=new Date(request.getSession().getLastAccessedTime())%>


        
        Cart List 

        
        
        
        
        <%

                String bookName = request.getParameter("bookName");
                List listOfBooks = (List) request.getSession().getAttribute("Books");

                if (listOfBooks == null) {
                    listOfBooks = new ArrayList();
                    request.getSession().setAttribute("Books", listOfBooks);
                }
                if (bookName != null) {
                    listOfBooks.add(bookName);
                    request.getSession().setAttribute("Books", listOfBooks);
                }


                for (String book : listOfBooks) {
                    out.println("
"+book + "
");
                }
            
        %>
        

        
            Book Name

What is the Problem In Simple Load Balancer?
If we deploy the web application, in which its used the session then actual problem is occurred.

I describe with sequence

1. User request one web page, in that web page its used sessions (like shopping cart).
2. Load balancer intercept the request and use the round robin fashion its send to one of the tomcat. suppose this time its send to tomcat1.
3. tomcat1 create the session and respond with cookie header to client.
4. load balancer just act as relay. its send back to client.

5. next time user request again the shopping cart to server. this time user send the cookie header also
6.Load balancer intercept the request and use the round robin fashion its send to one of the tomcat. this time its send to tomcat2.
7. Tomcat 2 receive the request and extract the session-id. and this session id is doesn't match with their managed session. because this session is available only in tomcat1. so tomcat 2 is create the new session and send new cookie to client
8. Client receive the response and update the cookie(Its overwrite the old cookie).

9. Client send one more time to request that page and send the cookie to server.
10. Load balancer intercept the request and use the round robin fashion its send to one of the tomcat. this time its send to tomcat3.
11. Tomcat 3 receive the request and extract the session-id. and this session id is doesn't match with their managed session. because this session is available only in tomcat2. so tomcat3 is create the new session and send new cookie to client
12. Client receive the response and update the cookie.(Its overwrite the old cookie).

13. Client send one more time to request that page and send the cookie to server.
14. Load balancer intercept the request and use the round robin fashion its send to one of the tomcat. this time its send to tomcat1.
15. Tomcat 1 receive the request and extract the session-id. and this session id is doesn't match with their managed session. because client session id is updated by tomcat 3 last time. so even though tomcat 1 have one session object created by this client. but client session id is wrong.so tomcat1 is create the new session and send new cookie to client (for more info watch the video below)
16. Client receive the response and update the cookie.

this sequence is continue ...

as the result every request one session is created. instead of continue with old one.

Here root cause is Load balancer. If load balancer redirect the request correctly then this problem is fixed. but how load balancer know in advance about this client before is processed by particular tomcat.
HTTP is stateless protocol. so HTTP doesn't help this situation. and other information is jsessionid cookie. its good but its just random value. so we can't take decision based on this random value.
ex:

Cookie: JSESSIONID=40025608F7B50E42DFA2785329079227

Session affinity/Sticky Session

Session affinity overrides the load-balancing algorithm by directing all requests in a session to a specific tomcat server. so when we setup the session affinity our problem is solved. but how to setup because session values are random value. so we need to generate the session value some how identify the which tomcat generate response.

jvmRoute

Tomcat configuration file (server.xml) caontain <Engine> tag have jvmRoute property for this purpose. so edit the config file and update the <Engine > tag like this

<Engine name="Catalina" defaultHost="localhost“ jvmRoute=“tomcat1” >

here we mention jvmRoute="tomcat1" here tomcat1 is worker name of this tomcat. check the workers.properties file in last post.

Add this line to all tomcat instances conf/server.xml file and change the jvmRoute value according to workers name and restart the tomcat instances.

Now all tomcat generate the session-id pattern like this

<Random Value like before>.<jvmRoute value>

ex: tomcat1 generate the session id like
Cookie:JSESSIONID=40025608F7B50E42DFA2785329079227.tomcat1

here tail have which tomcat generate the session. so load balancer easily find out to where we need to delegate the request. in this case its tomcat1.

so update all tomcat instances conf/server.xml file to add the jvmRoute property to appropriate worker name values. and restart the instances. all problem is fixed and entire load balance works fine even session based application.

but there is still one drawback

if 5 user acessing the website. In session affinity is setup. here

tomcat 1 serves 2 user,

tomcat 2 serves 2 user,

tomcat 3 serves 1 user, then suddenly one of instance is failed, then what happen?

suppose instance 1 (tomcat1) is failed, then those 2 users lost their session. but their request are redirect to one of the remaining tomcat instances (tomcat2,tomcat3). so they still access the web page. but they lost previous sessions. this is one of the draw back. but its compare to last post load balancer. its works in session based web application also.

next post we will see how to set up the session replication in load balancer.

please share ur thoughts through comments.

Update : Check the Session Replication Process in Third Part of this Series

Screen Cast:

Tomcat Clustering Series Part 1 : Simple Load Balancer

noreply@blogger.com (Rama krishnnan E P) — Wed, 10 Oct 2012 07:57:00 +0000

I am going to start new series of posts about Tomcat clustering. In this first post we will see what is problem in normal deployment in only single machine, what is clustering and why is necessary and how to setup the simple load balancer with Apache httpd web server + Tomcat server cluster.[Check the video for better understanding]

Why need Clustering? (Tomcat Clustering)
In normal production servers are running in single machine. If that's machine may be failed due to crashed or hardware defects or OutOfMemory exception then our site can't access by anybody.

so how to solve this problem?. to add more tomcat machine to collectively (group/cluster) run as a production server. (oppose of single machine). Each tomcat has deployed the same web application. so any tomcat can process the client request. If one tomcat is failed, then other tomcat in the cluster to proceeds the request.

Here one big problem is arrive. each tomcat instances are running in dedicated physical machine or many tomcat instances are running in single machine(Check my post about Running multiple tomcat instances in single machine). so each tomcat running on different port and may be in different IP.

the problem is in client perspective, to which tomcat we need to make the request? because there are lots of tomcat part of clustering is running. each tomcat we need to make IP and Port combination. like
http://192.168.56.190:8080/ or http://192.168.56.191:8181/

so how to solve this problem?
To add one server in-front of all tomcat clusters. to accept all the request and distribute to the cluster. so this server acts as a load balancer. There is lots of server is available with load balancing capability. here we are going to use Apache httpd web server as a load balancer. with mod_jk module.

so now all clients to access the load balancer (Apache httpd web server) and don't bother about tomcat instances. so now ur URL is http://ramkitech.com/ (Apache runs on port 80).

Apache httpd Web Server
Here we are going to use Apache httpd web server as a Load Balancer. To provide the load balancing capability to Apache httpd server we need to include the either mod_proxy module or mod_jk module. here we are using mod_jk module.

Before continuing this post check my old post (Virtual Host Apache httpd server) about How to install the Apache httpd server and mod_jk module. and how to configure the mod_jk.

How to setup the Simple Load Balancer
For simplicity purpose i going to run 3 tomcat instances in single machine(we can run on dedicated machine also) with Apache httpd web server. and single web application is deployed in all tomcat instances.

here we use mod_jk module as the load balancer. by default its use the round robin algorithm to distribute the requests. now we need to configure the workers.properties file like virtual host concept in Apache httpd server.

worker.list=tomcat1,tomcat2,tomcat3

worker.tomcat1.type=ajp13
worker.tomcat1.port=8009
worker.tomcat1.host=localhost

worker.tomcat2.type=ajp13
worker.tomcat2.port=8010
worker.tomcat2.host=localhost

worker.tomcat3.type=ajp13
worker.tomcat3.port=8011
worker.tomcat3.host=localhost

here i configure the 3 tomcat instances in workers.properties file. here type is ajp13 and port is ajp port (not http connector port) and host is IP address of tomcat instance machine.

there are couple of special workers we need add into workers.properties file.

First one is add load balancer worker, here the name is balancer (u can put any name).

worker.balancer.type=lb
worker.balancer.balance_workers=tomcat1,tomcat2,tomcat3

here this worker type is lb, ie load balancer. its special type provide by load balancer. and another property is balance_workers to specify all tomcat instances like tomcat1,tomcat2,tomcat3 (comma separated)

Second one, add the status worker, Its optional. but from this worker we can get statistical of load balancer.

worker.stat.type=status

here we use special type status.

now we modify the worker.list property.

worker.list=balancer,stat

so from outside there are 2 workers are visible (balancer and stat). so all request comes to balancer. then balancer worker manage all tomcat instances.

complete workers.properties file

worker.list=balancer,stat

worker.tomcat1.type=ajp13
worker.tomcat1.port=8009
worker.tomcat1.host=localhost

worker.tomcat2.type=ajp13
worker.tomcat2.port=8010
worker.tomcat2.host=localhost

worker.tomcat3.type=ajp13
worker.tomcat3.port=8011
worker.tomcat3.host=localhost


worker.balancer.type=lb
worker.balancer.balance_workers=tomcat1,tomcat2,tomcat3

worker.stat.type=status

Now workers.properties confiuration is finished. now we need to send the all request to balancer worker.
so modify the httpd.conf file of Apache httpd server

LoadModule    jk_module  modules/mod_jk.so

JkWorkersFile conf/workers.properties

JkLogFile     logs/mod_jk.log
JkLogLevel    emerg
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
JkOptions     +ForwardKeySize +ForwardURICompat -ForwardDirectories
JkRequestLogFormat     "%w %V %T"

JkMount  /status  stat
JkMount  /  balancer

the above code is just boiler plate code. 1st line load the mod_jk module, 2nd line to specified the worker file (workers.properties file). all others are just logging purpose.

The last 2 lines are important.
JkMount /status stat means any request to match the /status then that request forward to stat worker. Its status type worker. so its shows status of load balancer.

JkMount / balancer this line matches all the request, so all request is forward to balancer worker. In balancer worker ist uses the round robin algorithm to distribuete the request to other tomcat instances.

That's it.
now access the load balancer from the browser. each and every request is distribute to 3 tomcat instances. If one of the tomcat instances are failed then load balancer dynamically understand and stop to forward the request to that failed tomcat instances. Other tomcat instances are continue to work. If that failed tomcat is recovered from failed state to normal state then load balancer add to cluster and forward the request to that tomcat. (check the video)

Here big question is How Load balancer knows when one tomcat instance is failed or tomcat is just recovered from failed state?
Ans : when one tomcat instance is failed, load balancer don't know about that instances is failed. so its try to forward the request to all tomcat instances. If load balancer try to forward the request to failed tomcat instance, its will not respond. so load balancer understand and marked the state as a failed and forward the same request to another tomcat instances. so client perspective we not feel one tomcat instances are failed.

when tomcat instances recovered from failed state. that time also load balancer don't know that tomcat is ready for processing. Its still marked the state is failed. In periodic interval load balancer checks the health status of all tomcat instances. (by default 60 sec). after checking health status then only load balancer came to know that tomcat instance is ready. and its update the status is OK.

please share ur thoughts through comments.

Video :

Integrate Chart Image into Jasper Report Part - 2

noreply@blogger.com (Rama krishnnan E P) — Wed, 12 Sep 2012 08:06:00 +0000

In my previous post we discussed how to Integrate the Charts into Jasper Reports using JFreeChart API in Jasper Report. In this post there is another way to embeds the charts into Jasper Reports. This method, we need to generate/create the chart using any 3rd party Java Lib and convert into Image Object or stored into File-system, then just insert the Image into Jasper Report. here no need to use chart functionality in Jasper Report. because these chart are limited functionality.

Steps:

Create the chart using any Java libraries
Convert the Chart into BufferedImage or Stored into files
pass the Image into Jasper Report.

1. Create the chart using any Java libraries

In this step we going to create the chart. here i m using jopenchart Java library to create the chart. In their website tutorial section contain some sample codes. so i used these codes. and download the jopenchart lib from here.

2. Convert the chart into BufferedImage or Stored into files
In jopenchart have the in-build function for store chart into the file.
ChartEncoder.createPNG(new FileOutputStream(System.getProperty("user.home") + "/chat.png"), c);
and if u want into in-memory Image object then use render() method.

BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
DefaultChart chart = ....;
Graphics2D gd=bi.createGraphics();
chart.render(gd);

In above code we create empty BufferedImage object. the get the Graphics2D object from the BufferedImage and pass the Graphics2D into chart render() method. so when render() method is called, the chart is write into BufferedImage object.

3. Pass the Image into Jasper Report
We need to create the Jasper Report. this time we are not using chart function in Jasper reports. we using Image component of jasperreport. We have 2 options are there, pass the Image Object or Pass the Path String object where image is stored in File-system. here first i m using Image object.

we use parameter to pass into jasper report. so first create the new Parameter in Jasper Report and named "chartImage" and Parameter Class "java.lang.Object". drag the Image Component and set the properties. Image Expression and Expression Class like
Image Expression == > $P{chartImage}
Expression Class == > java.awt.Image

If we use stored Image File then change the Parameter class to java.lang.String and Image Expression Class to java.lang.String.

here Image Expression class is decided the Jasper Report. how we add the Image. If u put "java.awt.Image" as a Expression class then we are passing the Image object. and jasper report can understand. If u mention "java.lang.String" then we pass as String that pointing to Image file. (png,jpg,gif,..).

Code:
DemoBean.java

@ManagedBean
@SessionScoped
public class DemoBean {

    int width = 640;
    int height = 480;
    BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

    public DemoBean() {
        int[] quadr = {0, 1, 4, 9, 16, 25, 36};
        int[] exp = {1, 2, 4, 8, 16, 32, 64};
        double[] columns = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0};

        // Creating a data set array
        DefaultDataSet[] ds = new DefaultDataSet[3];

        // Filling all DataSets
        ds[0] = new DefaultDataSet(ChartUtilities.transformArray(new int[]{0, 6}),
                ChartUtilities.transformArray(new double[]{0.0, 6.0}),
                CoordSystem.FIRST_YAXIS,
                "Linear Growth");

        ds[1] = new DefaultDataSet(ChartUtilities.transformArray(quadr),
                ChartUtilities.transformArray(columns),
                CoordSystem.FIRST_YAXIS,
                "Quadratic Growth");

        ds[2] = new DefaultDataSet(ChartUtilities.transformArray(exp),
                ChartUtilities.transformArray(columns),
                CoordSystem.FIRST_YAXIS,
                "Exponential Growth");

        String title = "Growth Factor Comparison";



        DefaultChartDataModel data = new DefaultChartDataModel(ds);

        data.setAutoScale(true);

        DefaultChart c = new DefaultChart(data, title, DefaultChart.LINEAR_X_LINEAR_Y);

          c.addChartRenderer(new LineChartRenderer(c.getCoordSystem(),data), 1);

        c.setBounds(new Rectangle(0, 0, width, height));
        Graphics2D gd=bi.createGraphics();
        c.render(gd);

//      /*  if ur using Image file then use these code */
//        try {
//            ChartEncoder.createPNG(new FileOutputStream(System.getProperty("user.home") + "/chart.png"), c);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }


    }

    public String pdf() throws JRException, IOException {

       
        String reportPath = FacesContext.getCurrentInstance().getExternalContext().getRealPath("/reports/Charts.jasper");

        Map parameter = new HashMap();
        parameter.put("chartImage", bi);

        JasperPrint jasperPrint = JasperFillManager.fillReport(reportPath, parameter, new JREmptyDataSource(1));
        HttpServletResponse httpServletResponse = (HttpServletResponse) FacesContext.getCurrentInstance().getExternalContext().getResponse();
        httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.pdf");
        ServletOutputStream servletOutputStream = httpServletResponse.getOutputStream();
        JasperExportManager.exportReportToPdfStream(jasperPrint, servletOutputStream);
        FacesContext.getCurrentInstance().responseComplete();

        return null;
    }
}

Download the Sample Project from my GitHub

Check the screen-cast for better understanding.

Screen cast:

Integrate Charts in Jasper Reports +JSF 2.0

noreply@blogger.com (Rama krishnnan E P) — Wed, 05 Sep 2012 10:01:00 +0000

In this post we will walk through how to integrate Charts (JFreeChart) into Jasper Report framework. JasperReports is the world's most popular open source reporting engine. It is entirely written in Java and it is able to use data coming from any kind of data source and produce pixel-perfect documents that can be viewed, printed or exported in a variety of document formats including HTML, PDF, Xlsx, Docx, Pptx, Odf

Check my Introduction to Jasper Reports and Sub-report with jasper Report posts.

2-ways to Integrate the Charts/Graphs into Jasper Reports

Use JFreeChart API inside Jasper Report to generate the Charts while generating reports
Use any 3rd party Java Libraries to create the chart and stored in In-memory Image object (or) stored in file. then pass the Image/file to Jasper Report. then embed the Image into Report. (check here)

In this post we going to use 1st option. In Jasper Report use JFreeChart Components to make charts. In my next post we will see the 2nd way to generate the charts in reports.

I ll create one sample application (Progress Report) to demonstrate the Integrate the charts in reports.

I have Student Bean contain name, roll No, image and List of Semester paper beans. In Semester paper bean contain name of the paper and mark(score).

Student.java

import java.util.List;

/**
 *
 * @author ramki
 */
public class Student {
    private String name;
    private String rollNo;
    private String imagePath;
    private List listOfSemesterPaper;

    // getters and setters
}

SemesterPaper.java

public class SemesterPaper {
    
    private String name;
    private double mark;

   
    public SemesterPaper(String name, double mark) {
        this.name = name;
        this.mark = mark;
    }

    // getters and setters
    
}

Create the Report
we can use either iReport Standalone version or Jasper report Net-beans plugins to create the jasper Reports.

Create empty reports and create the fields and these fields are match with Student bean property variables. here name,rollNo and imagePath are String. so no need to change the data type of field. but listOfSemesterPaper is List. so change the data type of the field to List.

then drag Image component and static text component for making general report like this

here name and rollNo fields are dragged into report canvas, then drag the Image component and change the expression of Image component to imagePath field. Now we ready for bring the Chart component. But chart data are stored in listOfSemesterPaper field. Its List. So we can't use directly. so we going to create sub data set from main data set. so create sub dataset named "ChartDataset". and In sub data set create another 2 fields match with SemesterPaper bean. here name is String and mark is double.

Now drag the chart and choose the chart type. here i chosen Bar chart. its poped up the wizard. we need to choose Data set. here we need to choose "ChartDataset" sub data set, which one we created. then select the Category and Value property of Charts. here name is category and mark is value. (see the screenshot)

and final step is we need to explicitly mention how main data set is divied into sub data set. In sub data set "ChartDataset" is take value of listOfSemesterPaper field. this fields is List. so we need to wrap into JRBeanCollectionDataSource.

that's it. now compile the report and generate the .jasper format. then integrate into Netbeans project.

DemoBean.java

@ManagedBean
@SessionScoped
public class DemoBean {

    private List listOfStudent;

    public DemoBean() {
        listOfStudent = new ArrayList();

        Student student = new Student();
        student.setName("Ramki");
        student.setRollNo("02CS24");
        student.setImagePath("C:\\Users\\ramki\\Downloads\\ramki.jpg");

        List listOfSemsterPaper = new ArrayList();
        listOfSemsterPaper.add(new SemesterPaper("S/W Engg", 50.6));
        listOfSemsterPaper.add(new SemesterPaper("Java", 88.6));
        listOfSemsterPaper.add(new SemesterPaper("Data Struct", 66.6));
        listOfSemsterPaper.add(new SemesterPaper("Algorithm", 77.6));
        listOfSemsterPaper.add(new SemesterPaper("Lab 1", 90.6));
        listOfSemsterPaper.add(new SemesterPaper("Lab 2", 99.6));

        student.setListOfSemsterPaper(listOfSemsterPaper);

        listOfStudent.add(student);


    }

    public String pdf() throws JRException, IOException {
        JRBeanCollectionDataSource beanCollectionDataSource = new JRBeanCollectionDataSource(listOfStudent);
        String reportPath = FacesContext.getCurrentInstance().getExternalContext().getRealPath("/reports/chartReports.jasper");
        JasperPrint jasperPrint = JasperFillManager.fillReport(reportPath, new HashMap(), beanCollectionDataSource);
        HttpServletResponse httpServletResponse = (HttpServletResponse) FacesContext.getCurrentInstance().getExternalContext().getResponse();
        httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.pdf");
        ServletOutputStream servletOutputStream = httpServletResponse.getOutputStream();
        JasperExportManager.exportReportToPdfStream(jasperPrint, servletOutputStream);
        FacesContext.getCurrentInstance().responseComplete();
        return null;
    }
}

index.xhtml

    
        Facelet Title
    
    
        
            Generating Report :

Download the Sample Project from my GitHub

Watch in HD

Comments are Welcomed

Deploy the Java Web Application to Jelastic Paas Cloud

noreply@blogger.com (Rama krishnnan E P) — Fri, 22 Jun 2012 06:28:00 +0000

Jelastic is Java Paas (Platform as a Service) cloud for Java Server hosting. we can easily create the server instances(Tomcat, Glassfish ) and SQL Instances (MySQL, PostgreSQL) and deploy the Java Web applications.

Jelastic website make its easy to use. when we logged in one of the server then one window popped up, to create the environment

here we select servers (Tomcat, GlassFish), Database Servers (MySQL,PostgreSQL) and give the unique name of ur environment. then click create button. Jelastic create the tomcat and MySQL instances. these instance are not shared to others. so we can start/stop these instance at any time. we can change the config files like Tomcat (server.xml, catalina.properties), MySQL(mysql.ini) files.

When we create the instances they send mail contain the user name and password for accessing the Database server.

In this screen-cast (below) i deploy the previous post Jasper Report +JSF+JPA Web Application into Jelastic paas cloud.

Screen Cast

JSF + JPA + JasperReports (iReport) Part 2

noreply@blogger.com (Rama krishnnan E P) — Thu, 21 Jun 2012 10:12:00 +0000

In this post is a continuation of Jasper Report Part 1. here we will discuss about some advanced jasper report concepts like passing complex object like List, Date object and how to create and use local variable in jasper report, Add the sub-report and background image to report. Check my latest post about Integrate Charts into Jasper Reports.

here i am using JPA (Java Persistence API) for accessing the Database. so i create the two entity ShoppingCart and Item. here ShoppingCart entity contain list of Item entities. then i am going to pass these objects to Jasper Report. (Check the video in below)

ShoppingCart.java

@Entity
public class ShoppingCart {
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    private long id;
    private String firstName;
    private String lastName;
    @Temporal(TemporalType.DATE)
    private Date dop;
    @OneToMany(cascade= CascadeType.ALL)
    private List listOfItems;

    // getters and setters
}

Item.java

@Entity
public class Item {
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    private long id;
    private String itemName;
    private float price;
    private int noOfUnits;

    //getters and setters

}

Create Report
now i am going create report. we can use iReport standalone or iReport Netbeans Plugin to create the report. first we need to create some fields in report. these fields are matched with ShoppingCart Bean property names and Data types also.

and set the data types of these fields correctly.

firstName ==> java.lang.String

lastName ==> java.lang.String

dop ==> java.util.Date

listOfItems ==> java.util.List

then drag these fields to detail pane of the report as per needs. then right click the Report and compile the report

then its creates the jasper file. and its compiled format of jasper report. check part 1 for more details of overview of jasper report.

now create one JSF page with single Command Button (Submit Button)

    
        Facelet Title

and we create one managed bean for above JSF page
DemoBean.java

@ManagedBean
@SessionScoped

public class DemoBean {
    
     public void pdf() throws JRException, IOException {
     
         EntityManager em=PerisitenceManager.getEntityManager();
        Query query= em.createQuery("select s from ShoppingCart s");
         List listOfShoppingCart=(List)query.getResultList();
        JRBeanCollectionDataSource beanCollectionDataSource = new JRBeanCollectionDataSource(listOfShoppingCart);
        String reportPath = FacesContext.getCurrentInstance().getExternalContext().getRealPath("/reports/report.jasper");
        JasperPrint jasperPrint = JasperFillManager.fillReport(reportPath, new HashMap(), beanCollectionDataSource);
        HttpServletResponse httpServletResponse = (HttpServletResponse) FacesContext.getCurrentInstance().getExternalContext().getResponse();
        httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.pdf");
        ServletOutputStream servletOutputStream = httpServletResponse.getOutputStream();
        JasperExportManager.exportReportToPdfStream(jasperPrint, servletOutputStream);
        FacesContext.getCurrentInstance().responseComplete();
    }
}

Now when u run the project its generate the report in PDF file format.

now we integrate the sub report. so drag the sub-report component from palettes. then add the Item beans property as a fields names and correct data types.

and data types
itemName ==> java.lang.String
price ==> java.lang.Float
noOfUnits ==> java.lang.Integer

once sub report is ready then compile the subreports.

while create the subreport we passed the Empty Data Source. so now we need to change to listOfItems as a data source, we can't pass directly because its not accept List. so we need to wrap into the JRBeanCollectionDataSource Object.

so in main report select the sub report and change the properties

Connection Type ==> Use a datasource Expression
DataSource Expression ==> new net.sf.jasperreports.engine.data.JRBeanCollectionDataSource($F{listOfItems})

You Can Download this complete example from GitHub (or) google code .

How to use

Change the properties in persistence.xml file, like db name, db hostname ,username and password.
Add necessary lib to class path like Hibernate libs, MySQL lib, Jasper Report lib. for simplicity in this zip contain war file under dist/ folder. so just extract and see all lib are located in WEB-INF/lib section. copy all files and add to to ur class path (Libraries )
Create the jasperdb database in ur mysql server
First run the NewServlet , this servlet create necessary tables in ur database. and insert some sample rows to the table.
Finally run the index.xhtml file and generate the report.

~~I deployed same example in Jelastic Paas cloud, you can access through http://ramkicse.jelastic.servint.net/jasper/ URL~~
~~click the button to generate the report.~~ (Its expired)

check How to deploy the Web application to Jelastic cloud

Check my latest post about Integrate Charts into Jasper Reports

Screen Cast (Watch the video in HD)

Comments are Welcomed

How to do SSH Tunneling (Port Forwarding) - Screen-cast

noreply@blogger.com (Rama krishnnan E P) — Sat, 28 Apr 2012 10:43:00 +0000

In this post we will see how ssh works?, what is SSH tunneling? what is important of ssh tunnels and how to setup the ssh tunnel.
When SSH server is installed in machine then by default its allowed ssh tunneling.

SSH Tunneling (Port Forwarding)

Tunneling is the concept to encapsulate the network protocol to another protocol. here we put into SSH. so all network communication are encrypted. It also called Port Forwarding. because in ssh tunneling we are going to bind one local port. so what are the packet we are going to send that particular port, all packets are transparently encrypt and delivered to remote system.

What is the need for SSH Tunneling?

SSH is enough to administrate the remote system. its not enough to access the all services which are available in remote system.

let i describe in the following scenario,

now lets consider the scenario, System (192.168.56.101) is my system its connected to internet and server its called PrivateServer (192.168.56.102) machine have two Ethernet interfaces. one is connected to Internet. and another is connected to 10.10.1.0/24 local network. Intranet (10.10.1.11) machine is part of 10.10.1.0/24 sub network.

Note : here i mentioned local system(192.168.56.101) and remote system(192.168.56.102) are looking like local sub-net IP address. For VM purpose i used these IP address. But reality is it should be any public IP address.

Important Note : SSH Server daemon service is running in port 22 in all these three system and firewall is allowed to connect these system using SSH client.

now System (192.168.56.101) can communicate to PrivateServer (192.168.56.102), because both system are connected to internet directly. But System (192.168.56.101) can't communicate to Intranet (10.10.1.11) machine, because from System (192.168.56.101) perspective 10.10.1.11 is non route able IP address. 10.10.1.11 is not public IP address, its local IP address. so we can't route the packets directly.

Now the situation like that from System(192.168.56.101) i want to access the Intranet (10.10.1.11) machine. without modifying IP tables, redirect, like tools/services in intermediate (or) target machine. Because i m not sys-admin, so i don't have root privilege.

One of the possible solution is first use ssh to log in into PrivateServer(192.168.56.102) and then again (nested) log in to Intranet(10.10.1.11). Yes its good idea, its works, now i can remotely administrate the Intranet(10.10.1.11). but if Intranet(10.10.1.11) offer some services like VNC, Apache httpd, smtp, pop3, squid proxy then how we can access these services from System(192.168.56.101)?

here its not strictly Intranet(10.10.1.11) offer these service, it may be 10.10.1.0/24 sub net any one of the machine can offer these services. Even in 10.10.1.0/24 sub-net have one intranet-website. how we can access these site from System(192.168.56.101) machine Firefox?

The solution is SSH Tunneling or SSH Port Forwarding

How SSH Works

In terminal when we type ssh ramki@Private-Server.org then terminal application invoke the ssh client, ssh client connect to Private-Server.org's SSH server in port 22. then both client and server exchange the identity, public keys, cipher suite information and create one shell process in server side. then secure channel is established between client and server. then future all commands from 192.168.101 are go through this secure channel to server (192.168.56.102) and execute the command and the response are come back in same secure channel.

For example after establish ssh, i will issue the ls command. the ls command goes to SSH client then that command encapsulate and encrypted then send to server. Server decrypt and extract the command and execute the command in shell (which is created when ssh is established), the output of ls command is not printed in shell. Its redirect the output to SSH client in same secure channel and follow the same procedure (encapsulate and encrypt) . and finally Terminal application shows the output of ls command.

I think here all command is encoded to Base64 encoding before send to server and before encrypt. (But i am not sure)

here very important note that SSH is not disturb the port other than 22 (or which port ssh server is running).

SSH Tunneling

SSH can work many channel's simultaneously. In normal case we use shell channel. But now we are going to use data channel. so base concept is, in 192.168.56.101 machine ssh client bind one port and establish secure connection with server (192.168.56.102). and create one data channel and shell channel. (we can omit shell channel using -N option in ssh command).

Now In system machine ( 192.168.56.101) any application send data to that port (which one ssh client is bind), then ssh client transparently receive the data and encrypt and sent to server machine. In server ( 192.168.56.102) receive and decrypt it and make the local call. (we discuss later)

SSH Tunneling types

SSH offers three types of tunneling

Dynamic Tunneling (SOCKS Proxy)
Local Port Forwarding
Remote Port Forwarding

Dynamic Tunneling

Command : ssh -D 8080 ramki@192.168.56.102

here -D 8080 is mention SOCKS v5 Proxy bind 8080 port in client side

Now ssh client in 192.168.56.101 machine create one SOCKS proxy server in client side and bind one local port.then connect to 192.168.56.102 remote machine and establish secure channel.

Now all client application like Firefox, chrome,... need to configure the proxy setting to SOCKS proxy server localhost and port number. (check video for reference below the post)

Note : consider server (192.168.56.102) and Intranet (10.10.1.11) both machines run Apache httpd server and bind port 80

After configuration is completes,
in Firefox now type http://localhost/ , we know that in client machine (192.168.56.101) there is no service is running in port 80. but when we hit enter in browser, we can see the website of server machine (192.168.56.102).

How we can access server website using http://localhost/ in client machine?
we configure the proxy in browser. so browser send all HTTP request (even localhost anf 127.0.0.1) to port 8080, here SOCKS proxy is running in that port. Then socks proxy server packs our HTTP request to ssh client and encrypt and send to server. Server decrypt and extract the HTTP Request. Now in server side the HTTP request http://localhost/ is point to server machine itself. so server invoke the request. If any service is running in port 80, is called and response is send back to client using same secure channel. so browser shows server webpage in client side.

We know that from client machine (192.168.56.101) , the IP address 10.10.1.11 is non routable. but now if we issue http://10.10.1.11/ in Firefox browser, its shows the 10.10.1.11 Apache server webpage.

Advantage :

One proxy server is enough to access the all services of remote machine and its sub-net services

Disadvantage:

We need to configure the Proxy settings in client application, If application doesn't support the proxy then we can't access the service.

Local Port Forwarding

Command : ssh -L 8000:localhost:80 ramki@192.168.56.102

here syntax is -L <local port> : <remote hostname> : <remote service port>

so when we execute the command, its bind port 8000 in client side. now what are request send to port 6000 its redirect to ssh client, then encrypt and send to server machine. now server directly delivered the data to port 80.

In dynamic tunnel, server checks the packet and decide where we need to send the packet, for example http://localhost/ then its send to 80, smtp then send to 25. But in local port it always send to single port which one we mention during setup the local port forwarding <remote hostname> : <remote service port>

this time in Firefox no need to configure the proxy, clear the proxy(if its present)
and type in address bar http://localhost:8000/
then HTTP request is going to local port 8000, then its redirect and send to server. server directly send to port 80. (Its based on <remote hostname> : <remote service port>, here now localhost:80)

If u want to access the 10.10.1.11 machine http service then we need to setup new local port forwarding.

we can't use prior port forwarding. because old one always pointing to localhost:80.

Command : ssh -L 8000:10.10.1.11:80 ramki@192.168.56.102

now client side local port 8000 is redirected to 10.10.1.11:80 machine via 192.168.56.102.

In Firefox using http://localhost:8080/ we can access the 10.10.1.11 machine http service.

(For further reference check the video below. in video i show the how to access remote desktop using VNC)

Advantage:

no need to configure the proxy setting

Disadvantage:

Each service we need to setup different local port forwarding, (i.e for example, 2 port forwarding is needed to get 192.168.56.102 and 10.10.1.11 http services)

Remote Port Forwarding

Remote port forwarding is same like local port forwarding. but this time we need to set the port forwarding in server side(192.168.56.102), not client side

Command : ssh -R 8000:localhost:80 ramki@192.168.56.101
here very important changes is from server we going to connect client, so ramki@192.168.56.101 here its 192.168.56.101 not 102.

when we execute this command its connect to client and create 8000 port in client side(not server side).
as usual client use its local port 8000 to connect server. like local port forwarding.

Why Remote Port Forwarding is Important?
Its rarely used, when we worked the machine. that machine is inside the NAT. so from outside no one can access it. that kind of situation physically access the machine and connect back to our client system (192.168.56.101) using remote port forward. then from client machine we can access the services.(Its seems to be little bit confusing, but its simple)

In Windows Machine
In windows machine if want to run ssh server then there is lots of ssh servers are available WinSSHD freeSSHd, openssh. If we want only ssh client then we can use Putty.

suppose in System(192.168.56.101) i am using Windows then how we access the ssh tunneling.

open the putty and type the host ramki@192.168.56.102 and select Connection->SSH->Tunnels (see the image), then type 8080 in source port and select Dynamic, if u want dynamic tunnel (Its equal to -D 8080 in command option)

If we want local port forwarding then put any unused port 6000 in source port and destination is localhost:80 and select Local. (Its equal to -L 6000:localhost:80)

If u want to access 10.10.1.11 machine the remote desktop then make local port forward (check above image) and Destination is 10.10.1.11:5900 here 5900 is the port used by vnc server. then using any vnc client (here i used tightvnc client) to connect ur local port 6000

so mention localhost::6000, here we need to mention double colon ::, because in vnc client port no is specified in this manner. (Check the video )

Bypass Firewall
This SSH Tunnel concept can be use to bypass firewall. lets consider the scenario. In server side its enable firewall and some service are running and these services are can access through localhost or same machine. but u can't access through remote machine. because firewall block the all the port except ssh port (22).

this kind of situation we use tunnel and almost all services can be accessed from outside. because firewall is rule based. In firewall perspective all traffic is goes through port 22. so its allowed. but internally we made tunnel and access all services.

How to prevent SSH Tunnel
Open the ssh server config file /etc/ssh/sshd_config then set the parameter
AllowTcpForwarding no
then restart ssh service. then they not allow the ssh tunnel service, but still we can access ssh shell service.

But in ssh man page they clearly mentioned

" Note that disabling TCP forwarding does not improve security unless users are also denied shell access, as they can always install their own forwarders. "

so still we can use use ssh tunnel even though we set AllowTcpForwarding no. (I will show in my next post)

I hope everything is clear. If any misunderstanding please let me know.

Screen cast (Watch in HD)

Resources:

SSH, The Secure Shell: The Definitive Guide

Comments Welcomed

How to compile kernel step by step

noreply@blogger.com (Rama krishnnan E P) — Tue, 24 Apr 2012 05:49:00 +0000

Recently I compiled the latest kernel by manually for just fun. so i logged my experience here. I show the step by step to the compilation process. I followed the this reference for compile the kernel.

Why Need to compile the Kernel?

Some time some software or modules expected that some kernel flags needed to set while compile (build) the kernel. This kind of scenario we need to rebuild the kernel with specified configuration flags are set.
When new kernel is released, compile the new kernel and install in our system. But this is not recommend way to install the system. so use our distribution(Ubuntu, red-hat release ) kernel update.

Check your Linux kernel version
In Linux system use uname -r or cat /proc/version to find the current kernel version

Linux Kernel Version

here 2.6.35.22 is current system kernel version

Step 1 : Download the latest kernel
Goto http://kernel.org/ website and get the latest version of the kernel source. i will get 3.3.3

wget http://www.kernel.org/pub/linux/kernel/v3.0/linux-3.3.3.tar.bz2

and extract the source code.
tar xf linux-3.3.3.tar.bz2
cd linux-3.3.3
in linux-3.3.3 folder contain lots of files and folders. some folders are use following purpose

arch - this folder shows the what are the architecture port the Linux
crypto- contain cartographic implementations like AES, DES
drivers- all device drivers modules (IDE, SCSI, Ethernet device, Wireless)
fs- all file-system implementation code (ext4, FAT, NTFS)
net - all network protocol implementations (IPv4, IPv6, tcp, 802.11)

Step 2 : make the configuration file
While compile the kernel source code, we need configuration file. that configuration file contain lots of variable to help to understand what are the modules we need to compile.

For x86 specific kernel variable check this reference

using make command we can build the configuration, but this command is interactive, its ask more than 1000 question about enable or disable the particular module, like which file-system r u want and IP-Tables related modules like SIP components (state-full inspection firewall).

so the best way is copy the current Linux config file. its stored in /boot/config-<version>.
cp /boot/config-2.6.35.22-generic .config

now we got old configuration. now we change/add new configuration settings.
for this purpose therse is lots of options are avialable

make help ==>Provides the help

There is GUI option is also available

make menuconfig ==> this provides Text based GUI Configuration

here load the old config file and add/change the settings then save the config file.

make gconfig ==> this provides GTK 2 based GUI Configuration for GNOME

for this we need to install libgtk2.0-dev, libglad2-dev through apt-get install

make xconfig ==> this provides QT based GUI Configuration for KDE

for this we need qt-dev tools

Using any one of the above method modify the configuration.

Step 3 : Compile the Kernel

There are two ways to compile the kernel

Generic way (lots of steps)
Debian specific way (simple, Use make-kpkg tool)

Step 3.1 : Generic Way

Step 3.1.1 Compile the Kernel and its modules

  make
above code is take 1 to 2 hours depending on system performance. In this step it compile the kernel and store the kernel in binary form to arch/x86/boot/bzImage file
then based on kernel headers it will compile the kernel modules (device driver, file-system, network,...)
and generate .ko files. ko means kernel object. These modules also called Loadable Kernel Modules (LKM).

   Step 3.1.2 Install Kernel modules

make modules_install
This step copy the all kernel modules (*.ko) to /lib/modules/<version>/kernel/ folder.

   Step 3.1.3 Install Kernel

   make install
  This step copy the the kenel from arch/x86/boot/bzImage to /boot folder and copy the .config file to /boot/config-<latest-version> and generate the System.map file.

    Step 3.1.4 Create Initramfs file
up to now kernel and its modules are compiled and installed. when next boot up time we need to choose latest kernel. so we need to prepare the boot-loader and its support files. When system turns on, after bios and boot loader load the kernel to main memory and mount initial dummy file system as a root file system of system. this initial file system have necessary drivers for disk hardware (SCSI or IDE) and mount the correct file system as a root file system.

so we need to create initramfs file using update-initramfs or mkinitfs tool

   update-initramfs -c -k 3.3.3
here 3.3.3 is new kernel version.

Step 3.1.5 Update GRUB bootloader
the last step is update the boot loader here i m using GRUB boot-loader.

   update-grub
this command automatically probe the kernels in /boot folder and add the entries in its configuration file, grub.cfg

now restart the system , we will see the new kernel is added in boot loader entries. then choose new kernel in boot loader.

now open the terminal and issue uname -r command, its shows the current kernel version.

Step 3.2 : Debian specific way Way

In Debian system's (Ubuntu, Linux Mint,..) there is one tool "make-kpkg" is available to automate the kernel compilation process.

to install the make-kpkg, use apt-get
sudo apt-get install kernel-package libncurses5-dev

this one line command is compile the kernel and its modules and make the binary form in deb file.
make-kpkg --initrd --append-to-version=-ramki kernel_image kernel_headers

this one line make the kernel and its headers with custom suffix -ramki
--initrd specify that make initramfs disk file
kernel_image option to make the kernel and its modules
kernel_headers option to make all header files of the kernel. (optional)

the final output is its create 2 DEB files.

Install the Deb files
Install the deb file is simple. use dpkg tool like normal installation in Debian system
dpkg -i kernel_image-ramki-i386.deb

while executing this line install the kernel to /boot folder. install the modules in /lib/modules folder and create the initramfs file and update the grub like generic way. all the above operation is happen automatically.

then in optional case we can install the kernel_headers-ramki-i386.deb file.

why need the kernel headers are important?
kernel_image is enough to run the system. but when we need to install drivers, for example we need to install the new driver in Linux that time while compile the driver, that time need the kernel headers.

In my system its works fine. i tested in VM also.

Reference:

Comments Welcomed

Virtual Host + Apache httpd server + Tomcat + mod_jk connector

noreply@blogger.com (Rama krishnnan E P) — Tue, 20 Mar 2012 07:45:00 +0000

In my last post (Virtual Host in Tomcat) we discussed about how setup the virtual host in Tomcat. Its cost effective technique because only one public IP is enough to host multiple domain. If we have big organization and each department want to host their website in locally in different machine. then how to achieve the virtual host concept?. In this post we will see the how we do this.

Update : I posted Virtual Host + Nginx + Tomcat Its easy to configure, compare to Apache httpd server

Problem Scenario:
In big organization they have multiple department, each department want to host their website in different machine. so these websites are accessed locally with different local IP address.

When we mapping to public address then we face the problem. We have two choice either purchase as many public address or Put one server front and delegate these request.

We going to use 2nd option. we put Apache httpd web server in front of all department servers. so only one public IP is enough. All domain DNS entries are pointed to Apache httpd server. Then Apache server delegates these request to corresponding tomcat server. This process is completely transparent from users(browser) perspective.

Outline Structure of Virtual Host Implementation

How Apache httpd web server communicate to Tomcat server
Before we going to detail about how communication happen between httpd server and tomcat

How many ports are bind when we start single tomcat?

shutdown port
http connector port
https connector port (optional)
ajp port

The port configuration are stored in $CATALINA_HOME/conf/server.xml file. we can change the ports when its necessary.

here AJP(Apache JServ Protocol) is a binary protocol that can proxy inbound requests from a web server through to an application server that sits behind the web server.

Apache httpd webserver communicate to Tomcat sever through AJP protocol.

When we install Apache httpd server, It don't have inbuilt capability to support ajp protocol. so we need mod_jk module. Its add the ajp support to Apache httpd server.

Steps to Implement Virtual Host Concept in this Scenario:

Install Apache httpd Web Server
Install mod_jk connector
Configure JK Connector
Configure Apache httpd server apply virtual host concepts

Prerequisite : We already installed Tomcat in different departments and deployed the application and works fine.

Install Apache httpd web server
We can install Apache web server in two ways.
- Binary module
- From Source

We can install Apache httpd server from distribution package manager (either apt-get or yum). Or we can download the source code and then compile and install.

we use second option. First download the httpd server source code from here . then extract it and install

./configure --prefix=/usr/local/apache --enable-rewrite=shared --enable-proxy=shared
make
sudo make install

here

--prefix option to mention where the location we going to install Apache httpd server.

--enable-rewrite and --enable-proxy options to enable these module in shared mode. These modules are not needed now. but we used in future for rewrite the URL before handover to next chain of servers and load-balancing support.

Install mod_jk connector

Now Apache httpd server is ready. we need to add ajp support to server.

download the mod_jk connector module from here. extract it and install it

cd native

./configure --with-apxs=/usr/local/apache/bin/apxs

make

sudo make install

here --with-apxs option to specify where apxs module is located. so we need to give Apache httpd server location.

now mod_jk.so files is created on modules directory in apache installed location (/usr/local/apache/modules)

Configure mod_jk connector

This step have 2 sub step

Create workers.properties file
Load and configure the JK connector module in apache httpd.conf file

Create workers.properties file

mod_jk connector is ready. but this connector is works based on configuration file. so we need to create configuration file called workers.properties file

this file syntax is key=value pair,

here we define the workers. i.e all department tomcat hosts IP address and ajp port for corressponding tomcat.

here entry format is look like

worker.<name>.property=<value>

for example

worker.<name>.type=ajp13

worker.<name>.port=<ajp port>

worker.<name>.host=<tomcat ip addr>

worker.list=<name>

here

worker.list key have all workers name separated by comma.

type = here type of the worker. we use ajp13 version

port= we specify the ajp port (not http port ) of that server

host= IP address or host name of tomcat server

workers.properties

worker.list=department1,department2,department3

worker.department1.type=ajp13

worker.department1.port=5000

worker.department1.host=192.168.5.10

worker.department2.type=ajp13

worker.department2.port=5000

worker.department2.host=192.168.6.10

worker.department3.type=ajp13

worker.department3.port=5000

worker.department3.host=192.168.7.10

Add Entry in httpd.conf

Apache httpd server is installed. mod_jk module is installed and workers.properties file is created. but these 3 are isolated. we put together,
we need to configure the httpd server.

find the conf/httpd.conf file in Apache installed location and add these following entries to it

LoadModule jk_module modules/mod_jk.so

JkWorkersFile conf/workers.properties

JkLogFile logs/mod_jk.log

JkLogLevel emerg

JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "

JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories

JkRequestLogFormat "%w %V %T"

here

LoadModule - Load mod_jk shared module to Apache httpd server (enable the mod_jk module)

JkWorkersFile - Specify the workers.properties file location

all others are logging system of mod_jk. Its boilerplate code just copy and paste.

Delegate httpd to Tomcat

now we inform to Apache httpd server how delegate the request to corresponding server.

JkMount /department1* department1

JkMount /department2* department2

JkMount /department3* department3

here

JkMount - specify the if URL have /department1* pattern then that request delegate to department1 worker. that worker IP address and port is specified in workers.properties file.

Iwe changed /etc/hosts file like last post all web site domain pointed to apache httpd web server.

if we access http://www.ramki.com/department1/index.html how Apache httpd server process the request

Its perfectly called correct tomcat server and we got right response.

but we have 2 problem

1. i don't want the my URL like this http://www.ramki.com/department1/index.html

i want the my URL like this http://www.ramki.com/index.html

remove the department1 from my URL. but department1 string is very important in URL because JkMount is works based on this matching string only.

2. http://www.ramki.com/department1/index.html is for first tomcat and second department have domain http://www.krishnan.com then

access second tomcat we use URL : http://www.krishnan.com/department2/index.html

but same time when we use URL http://www.krishnan.com/department1/index.html then we access first tomcat data

(i.e )
http://www.ramki.com/department1/index.html == http://www.krishnan.com/department1/index.html

because both these URL have department1 key word.. so JkMount is works based on these keyword. As the Result wrong interpretation. How to solve this Issue?.

Virtual Host in Apache httpd Server

we need add conditional JkMount. for example ramki.com domain asks the whereare paths like department1,department2 we need to search in that tomcat only. not other place. to add this conditioned we add virtual host entries.

Add virtual host entry in httpd.conf file

Listen 80

NameVirtualHost *:80

<VirtualHost *:80>

ServerName www.ramki.com

JkMount /department1* department1

</VirtualHost>

<VirtualHost *:80>

ServerName www.krishnan.com

JkMount /department2* department1

</VirtualHost>

here

ServerName - domain name of the server

If http://www.krishnan.com/department1/index.html URL is like this now. server matches the Server Name. here its matches 2nd virtual host entry. There are single JkMount entry is there in 2nd Virtual-Host. and there no matching department1 string.

JkMount /department2* department1

as the result 404 error page is responded. Its works good.

Now everythig works fine.

now my URL is http://www.ramki.com/department1/index.html here i don't want department1 path in my URL.

i want simply http://www.ramki.com/index.html then we use mod_rewrite engine

Listen 80

NameVirtualHost *:80

<VirtualHost *:80>

ServerName www.ramki.com

RewriteEngine on

RewriteLog logs/apache-mod_rewrite

RewriteRule ^/(.*)$ /department1/$1 [L,PT]

JkMount /* <dept_name>

</VirtualHost>

here

RewriteEngine on - Turn on the Rewrite module

RewriteRule ^/(.*)$ /department1/$1 [L,PT] - here ^/(.*)$ its matches any string it capture the value to $1 and change the URL to /department1/$1

i.e

http://www.ramki.com/index.html here ^/(.*)$ its matches index.html it capture to $1 and replaced to /department1/$1 ==> /department1/index.html

Rewrite is happen before delegate the request to Tomcat. so we change the URL transparently to browser.

now client (browser) just send http://www.ramki.com is enough to access the Department 1 Tomcat.

Update : I posted Virtual Host + Nginx + Tomcat Its easy to configure, compare to Apache httpd server

I hope everything is clear. If any misunderstanding please let me know.

Screen Cast :

Comments Welcomed

Understanding Virtual Host Concept in Tomcat

noreply@blogger.com (Rama krishnnan E P) — Fri, 24 Feb 2012 08:35:00 +0000

Hi in this post we will see how to setup virtual host in Apache Tomcat server. Virtual Host is in-built feature that allows to deploy multiple website(domains) in single instance of tomcat server. The main benefit in this way is its cost effective.

Scenario:

I am going to deploy 3 website with following domain names in single tomcat

http://www.ramki.com
http://www.krishnan.com
http://www.blog.ramki.com

The following diagram is my outline.

Outline structure of Virtual Host Concept in Tomcat

Here my tomcat IP address 192.168.1.15. or any IP address allocated my ISP. but it should be public IP address.

How all domain names are pointing to my Tomcat?
When we purchase the domain name we need to update the our tomcat IP address to it. like

or we can simulate same DNS Setup through hosts file in both Linux and Windows. In Linux tha file is located at /etc/hosts

Now How Setup Virtual Host Concept?

Before going to setup the virtual host. first take look at the server.xml file in conf folder in tomcat directory.

server.xml

here <Engine> tag specified which engine is responsible for executing servlet. Here Catalina is the Engine.
<Host> tag specify the domain name and web apps base location. here default domain name is localhost and web apps base location is webapps folder in tomcat directory. here name attribute to specify the domain name and appbase attribute to specify the location of domain specific web apps folder path.

Now we need to add more <Host> tags to represent to our domains

<Host name="www.ramki.com" appbase="ramki_webapps" />
<Host name="www.krishnan.com" appbase="krishnan_webapps" />
<Host name="www.blog.ramki.com" appbase="blog_webapps" />

Then we need to copy the webapps folder in tomcat and paste it anywhere and rename it to ramki_webapps, krishnan_webapps, blog_webapps and update the path in <Host> tag

Modifies server.xml file

Simulate the DNS
Open the /etc/hosts file through root privilege and add following entry

192.168.1.15 www.ramki.com
192.168.1.15 www.krishnan.com
192.168.1.15 www.blog.ramki.com

deploy the websites to respective web apps folder and start the tomcat.

Test:
now open the browser and type http://www.ramki.com then its shows the ramk website content. Other two sites www.krishnan.com and www.blog.ramki.com works respective webapps.

In above diagram represent when we access www.ramki.com the tomcat server consult with server.xml file and serves the files from ramki_webapps directory.

How is Virtual Host Works
Here big question all websites are pointed to same tomcat. How tomcat can distinguished the request. (i.e) how tomcat knows browser requested ramki.com or www.krishnan.com

The answer is based Host header field in HTTP request.
when we accssed www.ramki.com then browser make HTTP request. and the request look like this

GET / HTTP/1.1
Host: www.ramki.com
Proxy-Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 6.2) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Encoding: gzip,deflate,sdch
Accept-Language: en-US,en;q=0.8

here Host Field contain domain name
Host: www.ramki.com

when tomcat receive the request from any browser, it read the Host field and understand which domain we requested, then consult the server.xml file and delegate to appropriate Host process thread

check my screen cast for setup

Comments are welcomed

screen-cast:

Understanding the GRUB boot loader and Customize the themes

noreply@blogger.com (Rama krishnnan E P) — Mon, 02 Jan 2012 10:27:00 +0000

In this post we will discuss the GRUB2 (GRand Unified Boot-loader) in Linux. recently i surfing the Linux base concepts then i came to know about grub2. here i ll share what is boot loader?, how grub2 boot loader is works? and how we can customize? and how we apply the themes?

What is the Boot Loader
Boot loader is small code reside in MBR to load the kernel(core) of the operating system and give the control to OS. When PC is switched on the system controls goes to BIOS. Bios initialize the peripherals and check the booting order of the device then select the highest priority of the device execute the code stored in MBR of that device. Each Operating System shipped with boot loader

For Example :-
Microsoft Windows up to Windows XP comes with NTLDR boot loader
From Windows Vista onward they use BOOTMGR as a boot loader.
These boot loaders are specifically designed to load Windows OS. If want use these boot loader to boot other OS (Linux, Mac OS X) then we need to tweak using 3rd party tools like easyBCD

For Linux Operating System uses many different boot loaders as distro choice like ISOLINUX, LILO, GRUB

Here we talk about GRUB2 boot loader.

What is Master Boot Record (MBR)?
Master Boot Record (MBR) is one block with 512 bytes. Its located in first sector of HDD, CD, other device. Its holds the partition entries and boot code.
Following MBR block, the actual partition are begin.

This is helps if disconnect the HDD and connected to other machine, that machine understands ur partitions and file systems.

HDD Layout and MBR

We know Total size of MBR is 512 bytes. In this 446 bytes for Boot code (Boot loader code) and 4 Partition entry, each 16 bytes long (64 bytes) and 2 bytes MBR signature.

Here this is limitation that one hdd is maximum 4 primary partition or 3 primary partition and 1 logical partition. The reason is MBR can store maximum 4 entry in partition table.

If we use logical partition, its not actually partition its another partition entry tables. its called extended partition table, it contain many entries to logical volumes. (see the above diagram)

Here each volume (or) partition has separate boot sector its called volume boot record apart from MBR. its used for chain-loader of boot loader. The reason is grub boot loader can boot all Linux and some Unix also (freeBSD, netBSD, openBSD).

GRUB Boot loader --> Load Linux Kernel

But it can't load the windows OS because GRUB don't know about Windows start-up process. Only Windows Boot-loader know about this. Windows Boot-loader stored in volume boot sector. First Grub is loaded and show the menu. Is user select the windows then GRUB load the volume boot sector code and give the control.

GRUB Boot loader --> Windows Boot loader --> Load Windows Kernel

Here one limitation for some boot loaders like Windows boot-loader. They can't boot the OS, if OS is installed in logical partition. that's why windows OS we must install in primary partition. because that boot code can't capable to access the logical volume.

The reason is if OS is installed primary partition then boot loaders easily can find the partition, because MBR contain primary partition entry.

But when u installed in logical partition then that partition entry is residing extended partition table. Boot loader get overhead to interpret the extended partition table and get the entry then load the OS.

Why GRUB2?
we already seen for Linux there are many boot loader. now let see why GRUB2 is more powerful than others.

GRUB2 is completely rewritten from original GRUB
Its modular based, so we can load any module when its needed
Its supports menu and themes
GRUB2 acts as a mini OS, we can mount many file-system
Its capable to boot ISO Linux directly. check here
Its capable to load the OS even though its installed logical volume.

GRUB2 comes as a default boot loader in many Linux like Ubuntu 9 onward's.

Normal GRUB Menu

How GRUB2 Works?
In 446 bytes in MBR is not enough to put entire grub code. so MBR contain small code called boot.img and its capable to read first block of core.img file from any partition (logical volume too) before partition is mounted. Because that time they cant understand the file system. so they read directly one sector (block) where core.img file is located.

The first block of core.img is called diskboot.img for HDD or cdboot.img for cd-rom or pxeboot.img for network boot. This block contain many address of blocks , to iterate these address and load blocks then the complete core.img (around 32 KB) comes into memory. This is job for boot code in GRUB.

Actually core.img file is generated when GRUB is installed . This file contain one or more necessary module to mount the File system, where GRUB is installed. So core.img file is responsible for mount the File system and access the GRUB configuration file. Once file system is mounted then we can access the files normal like Linux. All other modules are located /boot/grub. Its loaded when its needed.

All grub related configuration (menu entries, graphics resolution, timeout, etc...) are stored grub.cfg file in /boot/grub/ location. No need to put this line in MBR. because once File system is mounted then we can access through path /boot/grub/grub.cfg

now we see 2 important command for GRUB

sudo update-grub (or) sudo mk-config
this command generate the grub.cfg file dynamically. Its not update into MBR or volume boot record. Its just generate configuration file.

sudo grup-install /dev/sda
this command update the GRUB code in MBR. Its overwrite other boot loader code. (here sda is our HDD and dont mention any partition number)

sudo grup-install /dev/sda5
this command update the GRUB code in Volume boot record. (here sda is our HDD and 5 is 5th partition)

If u want to install GRUB in pendrive
first mount the pendrive and use grup-install command with --root-directory option

sudo grup-install --root-directory=/media/pendrive /dev/sdb
here /media/pendrive is mount point of pendrive and /dev/sdb is device file for pen drive , when want to know the device file run sudo fdisk -l

How grub.cfg file is generated?
when i run the update-grub command then its generate the grub.cfg file. But how?

When install grub on our machine (its time of OS installation) they created some supporting files. they located in /etc/default/grub file and /etc/grub.d/ folder.

/etc/default/grub - contain environment variables of GRUB
/etc/grub.d/  - contain some helper scripts files like theme,OS probe,custom scripts file

When we run update-grub command then its called scripts files sequentially accenting number order. These scripts files read environment variables from  /etc/default/grub file and generate the  grub.cfg file

grub.cfg file is read only. so don't modify directly

Customize the GRUB menu
  grub.cfg file is read only. so we need to modify the environment file or script file for customization.

Very important Note :
If u modify the /etc/default/grub file or /etc/grub.d/ scripts then its not reflected in grub.cfg file. So we must call the update-grub command to reflect these changes into grub.cfg.

1) Grub Time-Out
When we start the system, grub menu appears and wait for some time, is u not select the menu they load the default menu.
if u want to modify the time out option then change GRUB_TIMEOUT=30 in /etc/default/grub file

2) Change Graphics Resolution
  Usually graphics menu appears in low graphics resolution like 640x480. If u know the resolution then change GRUB_GFXMODE environment variable
for ex: GRUB_GFXMODE = 1024x768x32,640x480 here width x height x bit-depth

2) Change GRUB Background
Grub menu appears in normal black background. If u want to change the image of the background then create GRUB_BACKGROUND variable.
ex: GRUB_BACKGROUND=/home/ramki/Desktop/ram.jpg
Its accepts jpg,png,ttf format images

GRUB with background

If u want change the font colors and highlighting color.

Apply the Theme (see the video)
Above customization are just change the color and background. They not change the menu position and we can't add new labels and progress bar.

We can build the theme with some components (boot_menu, progress_bar, image, vbox, hbox) arranged our own way position and size in theme definition file.

each component have left,top,width,height properties. we can mention in pixel value or in percentage vale. Percentage is recommended.
after theme is created then we need to specify in GRUB_THEME variable in /etc/default/grub file

ex:
GRUB_THEME = /boot/grub/theme/theme.txt

This is screenshot of simple theme i used

After Applying Theme

Here we can use custom fonts also. but our fonts are not directly supported. we need to convert into pf2 format then we can use it.

sudo grup-mkfont --size=14 --range=0x0-0x7F --output=aerial.pf2 aerial.ttf
above line convert the aerial.ttf font to pf2 format with size is 14 and cover all character range.

If u want the above theme, u can get it from here then u modify the background image and other details

Update 1 :

Why we need to install bootloader in Volume Boot Record (VBR)?
The reason is if MBR bootloader is not capable to boot Particular OS then that boot loader do the chain loading to load VBR boot loader and gives the control.

for example there are 5 OS is there, but only one OS boot loader can sit in MBR. If that MBR bootloader is not capable to load other OS then how to load other OS. the answer is chain loading.

so all 5 os install in different partition then bootloader is installed in VBR and MBR. but MBR is overrides based on which on recently installed. but VBR have one more copy of that OS specific boot loader. If MBR boot loader is capable to boot another OS then no need VBR boot loader. But If MBR bootloader is not capable to boot particular OS then MBR boot loader load the particular OS partition VBR and gives the control. now VBR boot loader can boot that OS.

simple, 2 OS is there windows in sda2 partition and Linux in sda3 partition. and each partition contain their respective boot loader code in VBR. so sda2 VBR contain windows boot loader.

If GRUB bootloader is in MBR section, then it can load all Unix/Linux OS,but its can't load Windows OS. But windows boot loader is in sda2 VBR. so GRUB is load sda2 VBR to memory and gives control to it. Now Windows boot loader execute and load the Windows kernel.

Screen cast (Watch in HD)

comments are welcomed.

This entire post is based on my understanding of GRUB. If anything wrong or i misunderstood please let me know.

Resources:

http://en.wikipedia.org/wiki/GNU_GRUB

https://help.ubuntu.com/community/Grub2

http://grub.gibibit.com/

http://www.dedoimedo.com/computers/grub-2.html

The ThemingDefinitive Guide to GRUB2

Beware of SQLInjection in Java Application

noreply@blogger.com (Rama krishnnan E P) — Wed, 07 Dec 2011 09:22:00 +0000

Hi In this post we will discuss what is SQL Injection attack. and how its may affect ur any web application its use the backend database. Here i concentrate on java web application. Open Web Application Security Project(OWAP) listed that SQL Injection is the top vulnerability attack for web application. Hacker's they Inject the SQL code in web request to the web application and take the control of backend database, even that backend database is not directly connected to internet. And we will see how to solve and prevent the SQL Injection in java Web Application.

For this purpose we need 1 tools. these tool are completely open source.

SQL Map - SqlMap is an open source penetration testing tool that automates the process of detecting and exploiting SQL Injection. we can get it from here.

SQLInjection
SQL injection is the technique to extract the database information through web application.

Scenario:
we have one database server [MySQL] and web application server [Tomcat]. consider that database server is not connected to internet. but its connected with application server. Now we will see using web application how to extract the information using sql-injection method.

Before see the sql-injection, we create small web application. It contain single jsp page like this

<form action="userCheck">
<input type="text" name="user" value=""/>
<input type="submit" value="Submit"/>
</form>

In userCheck Servlet receives the user input field and connect to databse server and fire the sql query based on user input and receive the ResultSet and iterate it print into the web page.

userCheck servlet

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {

            String user = request.getParameter("user");
            Connection conn = null;
            String url = "jdbc:mysql://192.168.2.128:3306/";
            String dbName = "anvayaV2";
            String driver = "com.mysql.jdbc.Driver";
            String userName = "root";
            String password = "";
            try {
                Class.forName(driver).newInstance();
                conn = DriverManager.getConnection(url + dbName, userName, password);

                Statement st = conn.createStatement();
                String query = "SELECT * FROM  User where userId='" + user + "'";
                out.println("Query : " + query);
                System.out.printf(query);
                ResultSet res = st.executeQuery(query);

                out.println("

Results");
                while (res.next()) {
                    String s = res.getString("username");
                    out.println("

\t\t" + s);
                }
                conn.close();

            } catch (Exception e) {
                e.printStackTrace();
            }
        } finally {
            out.close();
        }

When we execute the above code. In normal input execution look like follows

When we give the normal value like "ramki" then click the submit button then output like this

Its perfectly correct in normal behaviour. what happen when i put some special character or some sql statement in input box like this

when we click the submit button then it show all rows in my table like this

Its big security breach in my application. what happen... Its one kind of sql injection

lets see what happen
when i enter normal value in input box my servlet receives and substitute in the sql query and execute it.

SELECT * FROM User where userId=' ramki '

its correct and we got correct output.

what happen when i put sdfssd' or '1'='1

SELECT * FROM User where userId=' sdfssd' or '1'='1'

its means

SELECT * FROM User where userId=' sdfssd' or '1'='1'

like this. so our query is altered. now new query have 2 condition. 2nd condition always true. 1st condition may be or may not be true. but these 2 condition are connected with or logic. so where clause always true for all rows. the result is they bring all rows from our tables.

This is called blind sql injection. If u want more details of sql injection the check here
http://www.unixwiz.net/techtips/sql-injection.html
http://www.imperva.com/resources/glossary/sql_injection.html
http://www.applicure.com/blog/owasp-top-10-2010

Now we can enter the sql statement directly in input box
like ramki' UNION SELECT * FROM mysql.`user` u --
then
SELECT * FROM User where userId='ramki' UNION SELECT * FROM mysql.`user` u --'
then its means
SELECT * FROM User where userId='ramki' UNION SELECT * FROM mysql.`user` u --'

here they wont use * because its not matched with first table. so they find how many columns then use Union with second table.the user particular column they want . as result the get mysql database user information its exposed through our web application.

sqlmap
It comes with a powerful detection engine, many niche features for the ultimate penetration tester and a broad range of switches lasting from database fingerprinting, over data fetching from the database

Install the sqlmap in ur system or use BackTrack Linux
Here I used backtrack linux. because its already pre installed lots of applications like sqlmap.
In backtrack, sqlmap is located in /pentest/web/scanner/sqlmap

sqlmap commands

retrieve all databases
./sqlmap.py -u http://localhost:8080/SQLInject/userCheck?user=ramki --dbs

retrieve all tables
./sqlmap.py -u http://localhost:8080/SQLInject/userCheck?user=ramki -D test --tables

retrieve all columns from particular table
./sqlmap.py -u http://localhost:8080/SQLInject/userCheck?user=ramki -D test -T User --columns

Dump all column valued from particular table
./sqlmap.py -u http://localhost:8080/SQLInject/userCheck?user=ramki -D test -T User --dump

Dump some column valued from particular table
./sqlmap.py -u http://localhost:8080/SQLInject/userCheck?user=ramki -D test -T User -C userId,password --dump

See the video for full demo (watch in HD)

How To Prevent SQL Injection

Before substitute into query, we need to do the validation. for remove ir escaped the special character like single quote, key words like select, Union...
Use Prepared Statement with placeholder

PreparedStatement  preparedStatement=conn.prepareStatement("SELECT * FROM  usercheck where username=?") ;
preparedStatement.setString(1, user);

that setXXX() method do all the validation and escaping the special charcter
Now if use same blind sql injection like sdfssd' or '1'='1 then

SELECT * FROM User where userId=' sdfssd\' or \'1\'=\'1'

here all special character are escaped

When we use JPA kind of ORM tools like Hibernate, EclipseLink, TopLink that time also may be sqlinjection is possible.
Preventing the SQL injection we need to use NamedQuery instead of normal Query. Because NamedQuery internally used PreparedStement but normal query used norma Stement in java.

Normal Query in JPA

String q="SELECT r FROM  User r where r.userId='"+user+"'";
 Query query=em.createQuery(q);
 List users=query.getResultList();

so dont use normal query, use Named query like this

Query query=em.createNamedQuery("User.findByUserId");
 query.setParameter("userId", user);
 List users=query.getResultList();

U can download the demo code from GitHub (or) Google code

Comments are welcomed

JSF + JPA + JasperReports (iReport) Part 1

noreply@blogger.com (Rama krishnnan E P) — Thu, 10 Nov 2011 04:11:00 +0000

Hi in this post we will see the overview of JasperReports and how to integrate into JSF application. JasperReports is the world's most popular open source reporting engine. It is entirely written in Java and it is able to use data coming from any kind of data source and produce pixel-perfect documents that can be viewed, printed or exported in a variety of document formats including HTML, PDF, Excel, OpenOffice and Word.

In Primeface library also use this JasperReports to generate the PDF, CSV and DOC formats with single line of code. see here. but its not flexible and we cant change template. so here we see the how to use JasperReports for create the template and integrate JSF 2.0.

We are using iReport tool for crating template.

Download JasperReports and iReport

Jasper Reports download from here. This zip contain jasper library and its dependencies and lots sample codes.
iReport download from here

Now create the simple JSF Application to retrieve the data from database using JPA, then create the template using iReport and then integrate into JSF application.

JSF+JPA
Java Persistence API is standard way to access the all ORM (Object Relational Mapping) tools like Hibernate, EclipseLink, TopLink,.. . These tools are internally use JDBC to access the database.

the Heart of JPA is consist of two parts

persistence.xml - Its xml file describe the persistence provider (ORM provider) and connection information like database URL, username and password. or data source.
Entity Classes - Its normal POJO class for each table in underlying table. This class is annotated with @Entity and some annotation provided by JPA. Its way to express and map the property in the class into table in the DB.

These entity class are manually we can create or using IDE tools like Net beans IDE provide "Entity Classes From Database" option to auto generate the Entity Classes. (See video in below)

Once these entity classes are created then we need to create CRUD methods to wrapping these entities for ease of use. These kind of classes also auto generate from "Session Beans from Entity Classes" option.

Here we using GlassFish Server 3. Its supports EJB 3.1.

Now we create the JSF page to display the entity classes in table structure and provide buttons for export into variety of formats.

index.xhtml


        Facelet Title
    
    
        
        
            
             
              
               
               
        
        
            
                
                    User Name
                
                #{user.userId}
            
            
            
                
                    Password
                
                #{user.password}

Jasper Reports

Once sample JSF application is completed then we going to integrate Jasper Reports.

First, include all necessary lib into our application. We already download the jasper library zip file. Extract this file they have lots of folder. one for dist folder contain main jasperreports-4.1.3.jar file and lib folder contain all necessary dependencies. see the requirements of jasper reports from here.

This is flow diagram of JasperReports.

Jasper Report Flow

Here we use iReport tool to generate the JRXML template. this file is pure xml file to describe the layout and place-holders. then we need to compile into jasper file. its binary format. this compilation process we can do in 2 ways.

Using iReport to compile the jrxml file into jasper
Using JasperReport API we can do through programme.

This is the code snippet compile the jrxml file into jasper file

JasperCompileManager.compileReportToFile("report.jrxml", "report.jasper");

or we can use iReport to compile

now compilation is finished. data is also ready. here data is java beans (entity beans) . This entity beans can't use directly. we wrap into one more class JRBeanCollectionDataSource then using JasperFillManager we generate JRPRINT object.

code:

JRBeanCollectionDataSource beanCollectionDataSource=new JRBeanCollectionDataSource(listOfUser);
JasperPrint jasperPrint=JasperFillManager.fillReport("report.jasper", new HashMap(),beanCollectionDataSource);

once JasperPrint is ready then we export using JasperExportManager

JasperExportManager.exportReportToPdfFile(jasperPrint, "report.pdf");

For exporting into docx, xlsx, odt, ods, pptx formats we should use JRDocxExporter, JRXlsxExporter, JROdtExporter, JROdsExporter, JRPptxExporter

and one more thing we don't want to store the exported format into file system. we need to send these formats to client via stream.

Code:

HttpServletResponse httpServletResponse=(HttpServletResponse)FacesContext.getCurrentInstance().getExternalContext().getResponse();
httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.docx");
ServletOutputStream servletOutputStream=httpServletResponse.getOutputStream();
JRDocxExporter docxExporter=new JRDocxExporter();
docxExporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
docxExporter.setParameter(JRExporterParameter.OUTPUT_STREAM, servletOutputStream);
docxExporter.exportReport();
FacesContext.getCurrentInstance().responseComplete();

here we get the OutputStream via FacesContext.

You can download this complete example from GitHub (or) Google Code

DemoBean.xml

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.ramki.jsf;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.export.oasis.JROdtExporter;
import net.sf.jasperreports.engine.export.ooxml.JRDocxExporter;
import net.sf.jasperreports.engine.export.ooxml.JRDocxExporterParameter;
import net.sf.jasperreports.engine.export.ooxml.JRPptxExporter;
import net.sf.jasperreports.engine.export.ooxml.JRXlsxExporter;
import org.ramki.entity.User;
import org.ramki.session.UserFacade;

/**
 *
 * @author ramki
 */
@ManagedBean
@SessionScoped
public class DemoBean {
    private List listOfUser;

    @EJB UserFacade userFacade;
    
    public List getListOfUser() {
        listOfUser=userFacade.findAll();
        return listOfUser;
    }

    public void setListOfUser(List listOfUser) {
        this.listOfUser = listOfUser;
    }
    JasperPrint jasperPrint;
    public void init() throws JRException{
        JRBeanCollectionDataSource beanCollectionDataSource=new JRBeanCollectionDataSource(listOfUser);
String  reportPath=  FacesContext.getCurrentInstance().getExternalContext().getRealPath("/reports/report.jasper");        jasperPrint=JasperFillManager.fillReport(reportPath, new HashMap(),beanCollectionDataSource);
    }
    
   public void PDF(ActionEvent actionEvent) throws JRException, IOException{
       init();
       HttpServletResponse httpServletResponse=(HttpServletResponse)FacesContext.getCurrentInstance().getExternalContext().getResponse();
      httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.pdf");
       ServletOutputStream servletOutputStream=httpServletResponse.getOutputStream();
       JasperExportManager.exportReportToPdfStream(jasperPrint, servletOutputStream);
       FacesContext.getCurrentInstance().responseComplete();
       
       
   }
    public void DOCX(ActionEvent actionEvent) throws JRException, IOException{
        init();
       HttpServletResponse httpServletResponse=(HttpServletResponse)FacesContext.getCurrentInstance().getExternalContext().getResponse();
       httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.docx");
       ServletOutputStream servletOutputStream=httpServletResponse.getOutputStream();
       JRDocxExporter docxExporter=new JRDocxExporter();
       docxExporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
       docxExporter.setParameter(JRExporterParameter.OUTPUT_STREAM, servletOutputStream);
       docxExporter.exportReport();
       FacesContext.getCurrentInstance().responseComplete();
   }
     public void XLSX(ActionEvent actionEvent) throws JRException, IOException{
        init();
       HttpServletResponse httpServletResponse=(HttpServletResponse)FacesContext.getCurrentInstance().getExternalContext().getResponse();
      httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.xlsx");
       ServletOutputStream servletOutputStream=httpServletResponse.getOutputStream();
       JRXlsxExporter docxExporter=new JRXlsxExporter();
       docxExporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
       docxExporter.setParameter(JRExporterParameter.OUTPUT_STREAM, servletOutputStream);
       docxExporter.exportReport();
       FacesContext.getCurrentInstance().responseComplete();
   }
      public void ODT(ActionEvent actionEvent) throws JRException, IOException{
       init();
       HttpServletResponse httpServletResponse=(HttpServletResponse)FacesContext.getCurrentInstance().getExternalContext().getResponse();
      httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.odt");
       ServletOutputStream servletOutputStream=httpServletResponse.getOutputStream();
       JROdtExporter docxExporter=new JROdtExporter();
       docxExporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
       docxExporter.setParameter(JRExporterParameter.OUTPUT_STREAM, servletOutputStream);
       docxExporter.exportReport();
       FacesContext.getCurrentInstance().responseComplete();
   }
       public void PPT(ActionEvent actionEvent) throws JRException, IOException{
       init();
       HttpServletResponse httpServletResponse=(HttpServletResponse)FacesContext.getCurrentInstance().getExternalContext().getResponse();
      httpServletResponse.addHeader("Content-disposition", "attachment; filename=report.pptx");
       ServletOutputStream servletOutputStream=httpServletResponse.getOutputStream();
       JRPptxExporter docxExporter=new JRPptxExporter();
       docxExporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
       docxExporter.setParameter(JRExporterParameter.OUTPUT_STREAM, servletOutputStream);
       docxExporter.exportReport();
       FacesContext.getCurrentInstance().responseComplete();
   }
    
}

Update (02/01/2012):

mourad mourad mentioned that report’s absolute path is hardcoded like C:\\UsersramkiDesktopreport.jasper". This doesn't work once you deploy your application in another application server.

Yes that's correct. now i fix it.. i used for simplicity purpose.

I try to used getResourceAsStream() method. But it wont work. the reason is our report needs some supporting files like images. If ur report contain no image then u can use getResourceAsStream() method.

So here i want the path of the report jasper file. Then this report engine get the images from that path.

String  reportPath=  FacesContext.getCurrentInstance().getExternalContext().getRealPath("/reports/report.jasper");
jasperPrint=JasperFillManager.fillReport(reportPath, new HashMap(),beanCollectionDataSource);

Update (22/02/2012):
DrAhmedJava commented that i noticed that you have an exception - getOutputStream() has already been called for this response- in your output, and it also happened to me. and i want to share the solution: (Thanks for sharing solution, i updated the code)
The idea is that after the pdf() method writes the pdf to http response, the jsf servlet itself tries to reopen the response to write the html rendered from rendering stage of the life cycle, so the solution is to tell the jsf servlet that the response is complete and to skip the rest of life cycle:

JasperExportManager.exportReportToPdfStream(jasperPrint, servletOutputStream); 
FacesContext.getCurrentInstance().responseComplete();

Update : For sub reports and Date Objects check Part 2 of this Series

Watch the video in HD

Comments are Welcomed

Learn Java 7

noreply@blogger.com (Rama krishnnan E P) — Mon, 18 Jul 2011 11:56:00 +0000

Java 7 is an upcoming major update to Java, releasing on July 28, its upgrade/add many features.

Upgraded Features
- Java 7 update the XML and Web Service stack to current stable build JAXP 1.4, JAXB 2.2 and JAX-WS 2.2.
- Update the Nimbus Look and Feel (Next Cross Platform UI). Its already added Java 6 Update 10. check here

- Translucent and shaped Windows
This feature is also included in java 6 update 10. this features provide to create transparent and any shape window in java. for more info check this

New features in java 7
Small languages changes (Project Coin Part 1)
Project Coin is one of the project in java 7 for java language spec (JLS). Project Coin have 2 parts. the first part is add to java 7. and next part is comes with java 8 in next year (2012).

Binary literals and underscore in numeric literals

now we can assign binary values directly.

int currency=19_00_000;
int binary=0b100000;
    
System.out.println(binary);
System.out.println(currency);

the output of above code snippets is 32 and 1900000

Strings in switch statements

now we can use string literals in switch statements.

public static void main(String[] args) {
       String data="java 7";
       
       switch(data)
       {
           case "java":
           case "JAVA":
               System.out.println("Java");
               break;
           case "java 7":
           case "JAVA 7":
               System.out.println("Java 7");
                break;
            default:
                   System.out.println("Otherthan java");
              
       }
        
}

it prints "Java 7".

Multi-catch statements and good re throw. Check Here
try with resource stements. check here
new diamond <> operator. check here

some other features of project coin will come with Java 8 in next year.

NIO 2 (New I/O 2)
This one of the biggest update in java 7. It fill the gap between underlaying OS and Java in terms of file manipulation. Oracle provide good tutorial about NIO 2 here

JLayer
JLayer is a universal decorator for Swing components which enables you to implement various advanced painting effects as well as receive notifications of all AWTEvents generated within its borders. check this tutorial about how to decorate JLayer in existing swing component.

Support for dynamically-typed languages (InvokeDynamic)

This feature is not for normal developers. Its only for those are porting his language into JVM. Check here for list of languages supported by JVM.

other features

Upgrade class-loader architecture
Support Uncode 6.0
Elliptic-curve cryptography (ECC)
JDBC 4.1
XRender Pipeline for mordern GPU

The Next Java 8 will give support for Modular JVM and modular programming (Project Jigsaw), Project Coin part 2, Project Lamda, collection literals and very importantly oracle going to merge JRockit into Hotspot VM.

comments are welcomed,

Running Multiple Tomcat Instances on Single Machine

noreply@blogger.com (Rama krishnnan E P) — Mon, 11 Jul 2011 13:54:00 +0000

In this post we will see how to run multiple tomcat instances on single machine and under single user account.
We first see the tomcat directory structure. .

here each folder uses following purpose.

bin - It contains all binary and script files for running tomcat.

lib - contains all shared libraries used for tomcat

conf - contains configuration information like which port tomcat can bind , etc...

logs - it contain all logging details

temp - this folder tomcat used for temporary files purpose

webapps - this folder is very important. here we put all application war files.

work - If application contain any jsp then jsp is translated and converted into servlet its stores here.

In when run the tomcat its uses 5 environment variables. They are

CATALINA_HOME, CATALINA_BASE, CATALINA_TMPDIR, JRE_HOME/JAVA_HOME, CLASSPATH

in above list CATALINA_HOME and JAVA_HOME is mandatory environment variables. all others are optional and its can be calculated using CATALINA_HOME.

CATALINA_HOME - this environment variable should point to tomcat base folder, where tomcat binary are installed/extracted. so based on CATALINA_HOME we can get bin and lib folder

CATALINA_BASE - If we not specified then CATALINA_HOME value is set. This variable pointed to configuration and webapps folder. Based on this variable server uses conf, logs, temp, webapps, work folders.

Usual ways to run the tomcat is only set CATALINA_HOME environment variable. and run the startup.sh script file. this startup.sh file automatically calculate and assign the values of other variables what we are not set.

startup.sh file set the environment variable and then call catalina.sh file. this files is read CATALINA_BASE value and attach conf i.e $CATALINA_BASE/conf folder and get server.xml. this file is heart of tomcat. it contains all configuration information. like which tomcat uses as shoutdown port, connector post, host name, application folder ,.. for example usually tomcat uses 8080 is a connector port, so we can access http://localhost:8080/

if we set the $CATALINA_BASE explicitly then tomcat uses our variable to search and get the server.xml file from our target place, what we specified in CATALINA_BASE.

this is trick to run multiple tomcat in single machine. we don't change CATALINA_HOME value. we need to change CATALINA_BASE value before start/shutdown the tomcat.

create one folder named "tomcat-instance1" anywhere, and copy conf, temp, webapps folder from CATALINA_HOME folder and change conf/server.xml file in tomcat-instance1. we need to change 3 port shutdown port, connector port and ajp port.

shutdown port - this port is used for shutdown the tomcat. when we call the shutdown.sh script they send signal to shutdown port. this port listen by tomcat java process. if signal is received the that process then its cleanup and exit by itself.

connector Port -This port is actual port to expose the application to outside client.

ajp port - this port is used to apache httpd server communicate to tomcat. this port used when we setup load balanced server.

see the sample server.xml file

.... ..


.....

so we change these three port to different number, because once this port is binded then other process can't bind it again. so wee bind different port. so tomcat-instance1/conf/server.xml file i configured server port =8105, connector port = 8181, ajp port = 8109.


.....

now we can create two script file for startup and shutdown the tomcat-instance1.
startup-instance1.sh
export CATALINA_BASE= /home/ramki/tomcat-instance1
cd $CATALINA_HOME/bin
./startup.sh

shutdown-instance1.sh

export CATALINA_BASE= /home/ramki/tomcat-instance1

cd $CATALINA_HOME/bin

./shutdown.sh

here we explicitly set the CATALINA_BASE variable and point to new tomcat-instance1
the we go to CATALINA_HOME/bin folder because all binary for running tomcat is still present in CATALINA_HOME folder then startup/shutdown the script.

Based on above technique we can create many instance folder and change conf/server.xml file port values and run that instance with own newly created script files.

Update 1:
Java Experience created a small utility for automatically generate the multiple tomcat instances in Windows/Linux Systems. Check Here

see the latest post :
Understanding Virtual Host in Tomcat

see the screen cast for running mutiple instance of tomcat

comments are welcomed

Understanding Java Server Faces 2.0 Part 3

noreply@blogger.com (Rama krishnnan E P) — Tue, 05 Jul 2011 11:29:00 +0000

This is Third part of JSF 2.0 discussion. Please visit part one and part two

Update : New Post JasperReports in JSF

In this post we will discuss JSF with AJAX. In JSF 2.0 gives full support for ajax integration in web application. With Ajax, web applications can send data to, and retrieve data from, a server asynchronously (in the background) without interfering with the display and behavior of the existing page. so with help of ajax we will make more interactive page. JSF 2.0 Faclets provide <f:ajax> tag for achieve ajax in web application without writing client side java script ajax code. JSF 2.0 takes care all of this.

JSF and ajax integration is one of the greatest feature. and no other framework provide this much easy ajax integration in web application.

Consider we have one simple web application it prompt the name and click submit button its display the name in same page in some where .

we will see this example without ajax

index.xhtml

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
      <center>
        <h1>JSF 2.0 Web Application</h1><br/>

        <h:form>
          Enter Your Name 
          <h:inputText value="#{demoBean.userName}"/>
          <h:commandButton value="Submit"/><br/>

          <h2>
             <h:outputLabel 
                    value="#{demoBean.sayHello()}"/>
          </h2>
       </h:form>
     </center>
    </h:body>
</html>

DemoBean.java

@ManagedBean
@SessionScoped
public class DemoBean {

    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String sayHello() {
        return "Hello, Mr." + userName;
    }
}

here when we click the submit button then entire page is refreshed, ie. complete page is downloaded from server and displayed in browser.

Integrate Ajax in JSF
JSF 2.0 provides full ajax support. so we no need to write client side java script for ajax. JSF 2.0 container generate client side java script, if we use <f:ajax> tag.

If we use <f:ajax> tag then JSF 2.0 container attached one java script file in generated response code.
that java script handles all ajax related events/actions.

now we change above example, add ajax in jsf
index.xhtml

<?xml version='1.0' encoding='UTF-8' ?>

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core">
  <h:head>
        <title>Facelet Title</title>
  </h:head>
  <h:body>
   <center>
     <h1>JSF 2.0 Web Application</h1><br/><br/><br/>

      <h:form>
         Enter Your Name 
         <h:inputText id="user_name" value="#{demoBean.userName}"/>
         <h:commandButton value="Submit">
            <f:ajax execute="user_name" render="display"/>
         </h:commandButton><br/>

         <h2>  
           <h:outputLabel id="display" value="#{demoBean.sayHello()}"/>
         </h2>
       </h:form>
     </center>
    </h:body>
</html>

here each component need id attribute. to distinguish between various components in page. <f:ajax> tags have some attributes. we nested inside the command button. so ajax event occur when command button clicked. Browser send ajax request to server. JSF 2.0 container proceeds the request and send partial response back to browser. JSF supplied java script takes care to parse the partial response and applied to DOM tree.

this is partial response returned by container

Hello, Mr.541-4160405675642876717:7702620445641245519

we will see <f:ajax> tag attributes

execute - while send the ajax request what are the parameters(or form fields) attach with request. here some predefined values are
@all - all components value in the page are submitted,
@this- only one component where we attach ajax tag that component value is submitted,
@form - current form (where ajax tag attached) fields are submitted

render - what are components we need to refresh (or update). here i mentioned 'display'. so only update the component whose id is display.

event - when ajax request should happen. default value is click, when we attached with command Button. or default value is change ,when attache with input text. here possible values are blur, change, valueChange, click, dblclick, focus, keydown, keypress, keyup, mousedown, mousemove, mouseout, mouseover, mouseup, select.

now we modify the index.xhtml to call ajax event for every key up event.

comments are welcomed

Understanding Java Server Faces 2.0 Part 2

noreply@blogger.com (Rama krishnnan E P) — Thu, 23 Jun 2011 12:44:00 +0000

This is Second part of JSF 2.0 discussion. Please visit part one

Update : New Post JasperReports in JSF

In JSF 2.0 part 1 post, i used @ManagedBean annotation for POJO java class. Its OK, actually it derived from JSF 1.2.But we should use @Named annotation instead of @ManagedBean, if CDI (Contexts and Dependency Injection) environment is available. I used Tomcat 7, its not Java EE 6 server and by default CDI is not available.

But we can use JBoss's Weld lib for achieve CDI in tomcat with minimal configuration. Weld is reference implementation of CDI and its comes standalone version also. This standalone version weld provide CDI environment for both Web Application and Java SE application. By default Glassfish 3.0/3.1 server comes with weld library for CDI Environment. Here i am using Glassfish server with CDI enabled.

Page Navigation
This post we will discuss page navigation in JSF2.0. Page Navigation means flow of the application. From one page to another page. In JSF1.2 page navigation is achieved through faces-config.xml configuration file. But JSF 2.0 that configuration file is optional. JSF2.0 gives new feature is Implicit Navigation. So in JSF2.0 we can use page navigation in two ways either implicit navigation or through configuration files. we will see the both.

Implicit Page Navigation
In Implicit navigation we can directly provide the next flow page in action attribute of JSF 2.0 tags. For example, we show one submit button in index.xhtml, when we click that button we should go to welcome.xhtml page

here action attribute just specify the welcome or welcome.xhtml directly. JSF 2.0 just pick the specific xhtml page and render that page.

Through faces-config.xml file Page Navigation
In JSF 1.2 navigation flow is achieved only through faces-config.xml. Its look like navigation file in Struts.

index.xhtml

In above JSF 2.0 code snippet they have two Submit Button. One have simple "success" literal in action attribute and another have one method in action attribute that method just return same "success" literal. Now JSF 2.0 first check in faces-config.xml, any navigation cases are match to the string literal, if matched then which to view id mentioned in faces-config.xml that page is rendered. even though success.xhtml page is found. If not found in navigation cases then JSF2.0 try to do implict navigation. If implicit navigation fails then it show to client, page navigation is failed due to that page is not found.

DemoBean.java

import java.io.Serializable;
import javax.enterprise.context.SessionScoped;
import javax.inject.Named;

@Named
@SessionScoped
public class DemoBean implements  Serializable{

    public String showWelcome()
    {
        // To do some bussiness logic
        return "success";
    }
}

So one thing is very important. faces-config.xml always take the high priority than implicit navigation, If its present.
faces-config.xml


    
        /index.xhtml
        
            success
            /welcome.xhtml

Forward Vs Redirect

Here we will discuss difference between forward and redirect. In JSF 2.0 by default it use forward only. For example if u run above example you can get following screen shots

when we click any submit button we get following welcome.xhtml page content. but still address bar pointing out index.xtml

We will discuss how forwarding works in JSF2.0. if user clicks submit button post the values, if any, to index.xhtml. In index.xhtml page return the success string literal. In both implicit and explicit page navigation find appropriate welcome.xhtml and render that page and return the content to browser. Browser is not aware that result is return by same page or different page. So browser still think about result content is return by same page.

Forwarding in JSF 2.0

Redirect
If you want to achive redirect in JSF 2.0. we should modify little bit. In Implicit Navigation we need to append "?faces-redirect=true". then JSF 2.0 consider this navigation ask redirect instead of forwarding.
If you want redirect through faces-config.xml file page navigation, then add <redirect/> tag in side <navigation-case> tag.

index.xhtml

faces-config.xml


    
        /index.xhtml
        
            success
            /welcome.xhtml

If we run the code with <redirect/> tag or ?faces-redirect=true

when user click the any submit button its shows welcome.xhtml page. Now see the address bar of the browser. Now its shows welcome.xhtml

How Redirect is works?.
Redirect is other hand. Now user click the submit button. Browser send the post the data to index.xtml. now index.xtml is processed. it return success literal and checks whether any redirect tag or implicit navigation ?faces-redirect=true are present or not. If it present the it simply return to browser with HTTP Status code 301. Its means the resource are temporally moved to another location welcome.xhtml. When the browser gets 301 status code the again connect to new resource welcome.xhtml. Now welcome.xhtml processed in server and return the content. Now browser render and display the content. So when browser get the resource its update that URL into address bar. so now we get welcome.xhtml in address bar.

Redirect in JSF 2.0

Here Forwarding have some advantage over redirect.

Forwarding makes both browser and server have more overhead and 2 connection need to establish.
Redirect solve the form re submission problem. and its good design

Forward is establish two HTTP connection. so overhead for both client and server. In some situation forward is best approach. consider the scenario you have one registation.xhtml page for registration form. User fill the data and click submit form fields are posted to server and updated either DB or List and return success/failed message page show to user. In the case success/failed message page is shown but address bar is still point to registation.xhtml. Because its forwarding, so same URL is showing. Now user click refresh button. then what happen? that page is re-submitted every time when we click refresh. That issue we can solve through redirect.

See the new screencast about this problem: http://www.youtube.com/watch?v=mkdn79S4TAM

Please visit part three

Comments are welcomed

Contexts and Dependency Injection Series

noreply@blogger.com (Rama krishnnan E P) — Thu, 23 Jun 2011 08:02:00 +0000

Contexts and Dependency Injection (CDI ) JSR 299 is a new feature in Java EE 6 Web Profile . Its Enhance the JSR 330 Dependency Injection in Java. CDI are highly used annotation. CDI makes Loose coupling between classes. To use javax.inject.Inject annotation, we can inject any class into another classes

i put 4 part series of CDI, you can get it here

Learning CDI (Contexts and Dependency Injection) Part 1

Learning CDI (Contexts and Dependency Injection) Part 2

Learning CDI (Contexts and Dependency Injection) Part 3

Learning CDI (Contexts and Dependency Injection) Part 4

Why should I learn JSF

noreply@blogger.com (Rama krishnnan E P) — Tue, 21 Jun 2011 06:26:00 +0000

Java Server Faces (JSF) is one of the presentation web frameworks in java. There is lots of others frameworks like Spring, GWT, Wickets, Struts. Today this post we ll discuss why JSF is more important then others.Here I am not criticize any frameworks. i just talking about JSF.

In JSF 1.2 and previous version of JSF used JSP as a view declarative language and JSP life cycle is not matched with JSF and ajax requests. JSF 1.2 are complex to use and they have some short coming in feature.

But JSF 2 is completely changed the adapt lots of technologies, but still its support backward compatible.Its very easy to learn. More over JSF is center piece in Java EE 6 Spec. It means that what are the new components or specification introduced in Java EE 6 are seamlessly integrated into JSF. Because those components spec is designed for JSF in mind.

New Components / Specification added in Java EE6 spec

CDI 1.0 (Contexts and Dependency Injection)
Bean Validation 1.0
Java Persistence API 2.0
EL 2.2 (Expression Language)

Above spec is added in Java EE 6 and well integration with JSF. JSF comes with basic components of HTML User Interface (UI). JSF is extensible. So with help of third party libraries like PrimeFaces, IceFaces, ADF Faces, ... gives Rich UI.

When JSF 2 spec is gives direct competition to other web frameworks. JSF derive lots of good feature from Spring, GWT, Seam Framework.

Why should I learn JSF

JSF spec is controlled by JCP (Java Community Process) and its standard for Java EE server
There is no vendor locking, because JSF is spec, we can use any implementation of JSF, for example Mojarra, MyFaces are JSF2.0 implementation.
JSF is part of Java EE 6. so when your server is Java EE 6 compliant server. then its must support JSF 2. so no need to configure externally and no need to put web framework jar in class path.
In Java CDI is direct compete with DI in Spring and Guice in Google . In JSF 2 Navigation Component is compete with Spring Web Flow. JSF 2's Ajax Framework components compete with GWT. so what i conclude here, each and every component is good/best
In JSF 2 is easy to implement with help of annotation. Annotation is makes all configuration files are optional. No more XML. Now Spring start supporting annotation instead of XML configuration.
Java EE components like CDI, Bean Validation, JPA are standardized and used in Enterprise Level and Java SE also. But other frameworks components are de-facto standard.

Java EE 5 had a big gap for enterprise application so we need those frameworks to fill the gap. but Java EE6 mostly fill the gap. If your working in Java EE 5 compliant server then you should go with those frameworks.
If you take case study of JPA, before JPA come into picture, EJB 2.1 use persistent entity classes for persistent. its very difficult to study. Then Spring comes with easy solution POJO class used for persistent. then JPA comes with improved solution with help of annotation. Now JPA is standard for all ORM libraries like Hibernate, EclipseLink, etc.. Now EJB 3.1 uses JPA 2.0 is persistent purpose.
Now Spring start support for CDI, Bean validation and other components in Java EE 6
Even you can easily integrate JSF pages in Spring

If anything i mentioned wrong please put your thought in comments.

Please Check Understanding Java Server Faces 2.0 Part 1
Understanding Java Server Faces 2.0 Part 2

Understanding Java Server Faces 2.0 Part 1

noreply@blogger.com (Rama krishnnan E P) — Sat, 18 Jun 2011 13:03:00 +0000

Update : I put new post for Why should I learn JSF
I put new post for Understanding Java Server Faces 2.0 Part 2

JavaServer Faces (JSF) is a Java-based Web application framework intended to simplify development integration of web-based user interfaces. Java Server Faces (JSF) 2.0 is a improved component of Java EE 6 Specification. Its Component based model. Its is alternative technology for Struts, JSP, Spring. Its MVC (Model-View-Controller) based architecture.

If JSF 2.0 is compared to its previous version JSF 1.2, there are more functionality are added

Facelets is a default View Declartion Language (VDL)
Full spport for AJAX
Composite components
Beans Validation
Implicit navigation

Facelets
Facelets used to describe the UI in tag styled format. Its extension is .xhtml and application usually accessed in .jsf, .faces, .xhtml . we can configure in web.xml.

Lifecycle of JSF

The above diagram is JSF life cycle. we explain this life cycle with sample JSF Application

we have 2 JSF pages and one bean java class

index.xhtml

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html">
    <h:head>
        <title>Sample JSF Application</title>
    </h:head>
    <h:body>
        <h:form>
            Enter your Name 
            <h:inputText value="#{demoBean.name}" required="true" />
            <h:commandButton value="Submit" action="welcome" />
            
        </h:form>
    </h:body>
</html>

welcome.xhtml

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html">
    <h:head>
        <title>Welcome Page</title>
    </h:head>
    <h:body>
        Hello #{demoBean.name}
    </h:body>
</html>

DemoBean.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.ramki.bean;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

/**
 *
 * @author ramki
 */
@ManagedBean()
@SessionScoped
public class DemoBean {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

here each web page uses the facelet tag library

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html">

so, we need to add the tag library in html with prefix 'h' by default.

each HTML UI elements like text field, button, checkbox, etc... Facelets has equal tags to fullfill the standard UI like <h:inputText>, <h:commandButton>,etc...

when we execute this application index.xhtml page is translated into views. View is collection of UI components arranged paricular manner. for example our index.xhtml page turns into View

View Tree of index.xhtml page

UIViewRoot is Top level components add HtmlOutputHead and HtmlOutputBody. These 2 components translated in <head> and <body> tag in Render phase. In body component has input text field and command button components.

If browser request index.html first time the Phase 1 & 6 only executed all other phases are bypassed

Phase 1 : Create / Restore View
Every JSf page is create the view. the that view is cached for future use. for example index.html page is requested by browser then container search index.xhtml view tree. Above diagram is view tree of index.xhtml page.If found in cache the restore the view, otherwise create the view tree.

Phase 6 : Render the View
JSF have Render Kit to render the view to generate appropriate format. for example HTML render kit generate html code from view. Render kit knows how to render the UI components.

now user fill some details in index.xhtml the click some action the same page is requested to server now this time index.xhtml tree view is restored and run all remaining phases.

Phase 3: Apply values from User to View
if user sends some data like POST or GET form values, this phases apply this values to the Tree View like fooling diagram

Phase 4: Validate the values
This is optional phase. if any validations is mentioned then this phases is executed. otherwise it simply bypassed. for example in index.xhtml input text field we mentioned required=true its one of the validation. so if submit the form without filling values this phases reporting exception and forward to directly render phase. all other phaes are bypassed. if this phases execute without exception the phase 5 is executed

Phase 5: Fetch New View
In this phases is responsible for find the next view to render and displayed to user. for example our example in command button has action property to mentioned welcome value. in this phase find the welcome.xhtml page and gives to render phase. here we used implicit navigation its one of the features of JSF 2.0

When we run the above example

Update : I put new post for Why should I learn JSF

I put new post for Understanding Java Server Faces 2.0 Part 2

Watch the you tube with 480p or 720p

Comments are welcomed

Understanding CDI (Contexts and Dependency Injection) Part 4

noreply@blogger.com (Rama krishnnan E P) — Fri, 10 Dec 2010 08:10:00 +0000

This is Fourth part of CDI discussion.Please visit part one, part two and part three

Interceptors
Interceptors is one feature of CDI. Using this feature we can intercept the method call. Its counterpart technique for Aspect Oriented Programming (AOP) in Spring. Its helps to analysis the business methods and these interceptors are disabled by default. so we can enable/disable the interceptor in deployment time through beans.xml file.

Create interceptor
To create interceptor involves two step process. first to create interceptor binding and implement the interceptors.

here we create Log Interceptor, so we need to create Log Interceptor Binding(its like qualifier)

Log.java

package org.ramki.interceptor;

import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.interceptor.InterceptorBinding;

/**
 *
 * @author Ramakrishnan
 */
@Inherited
@InterceptorBinding
@Retention(RUNTIME)
@Target({METHOD, TYPE})
public @interface Log {
}

here @InterceptorBinding is represent that the annotation 'Log' is interceptor

second, we need to implement the interceptors

LogImpl.java

package org.ramki.interceptor.impl;

import javax.interceptor.AroundInvoke;
import javax.interceptor.Interceptor;
import javax.interceptor.InvocationContext;
import org.ramki.interceptor.Log;

/**
 *
 * @author Ramakrishnan
 */

@Interceptor
@Log

public class LogImpl {

    @AroundInvoke
    public Object logging(InvocationContext context) throws Exception
    {
        System.out.println("Log before method call...");
        Object returnObject = context.proceed();
                // to do some logging
        System.out.println("Log after method call...");
        return returnObject;
    }
}

here @Interceptor represent that its interceptor implementation
@Log specifies to which interceptor implementation , both of these lines shows that this class is Log interceptor Implementation

@AroundInvoke is comes before one method defines
that method must pass the below method signature

public Object <methodName> (InvocationContext context)

here methodName is any name we can give.
in that method call context.proceed() - to call actual method

so when we call any intercepted method then the container calls this method and here do pre-processing then call actual method through context.proceed() and finally we can do some post-processing...

Apply Interceptor
Once interceptor is ready, then we can apply any business class
SimeClass.java

package org.ramki.beans;

import org.ramki.interceptor.Log;
import org.ramki.interceptor.Time;
/**
 *
 * @author Ramakrishnan
 */


@Log


public class SomeClass {

    public void methodA() {
        System.out.println("indide methodA...");
    }

    public void methodB() {
        System.out.println("indide methodB...");
    }

    public void methodC() {
        System.out.println("indide methodC...");
    }

    public void methodD() {
        System.out.println("indide methodD...");
    }

    public void methodE() {
        System.out.println("indide methodE...");
    }
}

here i put @Log in class level. we can put method level also (i.e we can put some methods )

Interceptor is disabled by default. so we need to enable through beans.xml




           
                org.ramki.interceptor.impl.LogImpl

Through servlet/jsp if u try to call business method of SomeClass class, its do all pre and post processing through interceptors.

Comments are welcomed

Scree cast
please watch video in HQ mode

Comments are welcomed

Understanding CDI (Contexts and Dependency Injection) Part 3

noreply@blogger.com (Rama krishnnan E P) — Mon, 06 Dec 2010 06:56:00 +0000

This is Third part of CDI discussion.Please visit first part and part two,

@Alternative
In part two we seen @qualifier 's to resolve the unambiguous problem for one interface and more than on implementation. In qualifier helps to solve in development time. (i.e all meta information is stored in class files).
Another solution is @Alternative annotation solve the problem in deployment time. all configuration is stored in beans.xml in WEB-INF folder

We take same example what we discussed in last part

one interface (Hello) and two implementation(HelloImplOne, HelloImplTwo)
here i marked @Alternative in both implementation

Hello Interface

package org.ramki.service;

/**
 *
 * @author ramki
 */
public interface Hello {

    String sayHello(String name);
}

HelloImplOne Implementation

package org.ramki.service;

/**
 *
 * @author ramki
 */
@Alternative
public class HelloImplOne implements Hello {

    @Override
    public String sayHello(String name) {
        return "Hello, Mr "+name;
    }

}

HelloImplTwo Implementation

package org.ramki.service;

/**
 *
 * @author ramki
 */
@Alternative
public class HelloImplTwo implements Hello {

    @Override
    public String sayHello(String name) {
       return "Hi, "+name;
    }

}

and go and modify the beans.xml in WEB_INF folder



      
             org.ramki.service.HelloImplTwo

In <alternatives> tag in beans.xml we need specify which one need to inject.

See the screen cast for demo

Comments are welcomed

Ramki Java Blog

Tomcat Clustering Series Part 5 : NginX as Load Balancer

First define Upstream block in nginx.conf file

Second forward (proxy) the request to back-end servers

Tomcat Clustering Series Part 4 : Session Replication using Backup Manager

Case 1:

case 2:

Note:

Screen Cast:

Tomcat Clustering Series Part 3 : Session Replication

Standard Manager

Persistent Manger

Delta Manger

Backup Manager

1. Enable Multicast routing

2. Add <Cluster> Entries in conf/server.xml file for all instances.

3. Enable the Web Application as distributable

Reference:

Screen Cast:

Tomcat Clustering Series Part 2 : Session Affinity Load Balancer

Session affinity/Sticky Session

Update : Check the Session Replication Process in Third Part of this Series

Tomcat Clustering Series Part 1 : Simple Load Balancer

Integrate Chart Image into Jasper Report Part - 2

Integrate Charts in Jasper Reports +JSF 2.0

Deploy the Java Web Application to Jelastic Paas Cloud

JSF + JPA + JasperReports (iReport) Part 2

How to do SSH Tunneling (Port Forwarding) - Screen-cast

How to compile kernel step by step

Virtual Host + Apache httpd server + Tomcat + mod_jk connector

Update : I posted Virtual Host + Nginx + Tomcat Its easy to configure, compare to Apache httpd server

Update : I posted Virtual Host + Nginx + Tomcat Its easy to configure, compare to Apache httpd server

Understanding Virtual Host Concept in Tomcat

Understanding the GRUB boot loader and Customize the themes

Beware of SQLInjection in Java Application

JSF + JPA + JasperReports (iReport) Part 1

Learn Java 7

Running Multiple Tomcat Instances on Single Machine

Understanding Java Server Faces 2.0 Part 3

Understanding Java Server Faces 2.0 Part 2

Contexts and Dependency Injection Series

Learning CDI (Contexts and Dependency Injection) Part 1 Learning CDI (Contexts and Dependency Injection) Part 2 Learning CDI (Contexts and Dependency Injection) Part 3 Learning CDI (Contexts and Dependency Injection) Part 4

Why should I learn JSF

Understanding Java Server Faces 2.0 Part 1

Understanding CDI (Contexts and Dependency Injection) Part 4

Understanding CDI (Contexts and Dependency Injection) Part 3

Learning CDI (Contexts and Dependency Injection) Part 1

Learning CDI (Contexts and Dependency Injection) Part 2

Learning CDI (Contexts and Dependency Injection) Part 3

Learning CDI (Contexts and Dependency Injection) Part 4