bogdan@j3e

Key takeaways from my TDD training sessions

bserban — Sun, 21 Feb 2010 11:38:33 +0000

Recently I had the chance to participate to a Test Driven Development session. Until now I never tried TDD I just simply used the TFP (Test First Programming), so let’s see what are the differences between Waterfall model, TDD and TFP. After that I’ll list some key points about doing TDD.

Programmers’ headache started in 1970 when Winston Royce published the Waterfall model. This model was based on a set of sequential steps: Analysis, Design, Code, Test, Maintain. The big assumption made was that the design precedes the coding phase and the testing phase comes after the coding. A very structured approach. This is a description of a well defined process which works great on other industries but the practice proved that software development is an empiric process rather than a very well defined one and for such process you need a short feedback loop. This assumption is the foundation of the agile methodologies which are surfacing the project problems since the beginning.

Test Driven Development and Test First Programming are reducing the gap between testing and design allowing you to adapt your design as you go. The Test First Programming assumes that you have a design upfront and you start your coding by writing tests to validate your design. The loop is only between code and tests but no for design. This is in fact a longer development cycle because the design is corrected at the later time.

TDD assumes that you don’t have design upfront, your design emerges with the code and you have a loop between all three key elements: Test, Design, Code. Now you can incorporate testing feedback into design and code as you go. Such a cycle should take around 30 minutes.

The four golden rules of TDD:

Add code on red

Delete code on green

Remove duplications

Fix bad names

The development cycle look likes this:

Key takeaways:

With TDD you take the design decision as late as you can.
TDD maximize code clarity
With TDD you go steady, you will get speed on the way
Your code is more changeable and you are able to accommodate the changes with less effort
Run your tests very often, try every 5 minutes
If you have a long build time then TDD will surface these problems. Probably you have dependencies problems.
Try to reduce the compile time of your work to 30s
There is no such thing as large modular system. If it is modular then your module should compile and build fast.
Name the methods correctly
Name methods after what they do and look after “Or” “And” method names, something is wrong there.
Look for multiple responsibilities and remove them
If the data is not where you need it then something is wrong.
Follow the open close principle
The link between inputs and outputs should be clear for the tests
When you have design disputes you can branch and meet after 1h
Stop when no new feature or new defect force you to refactor
Refactoring depends on the personal appetite
If you go back after 1 week you should understand the code completely
Write the test for single threaded, if your code runs in multithreading environment then apply the rules of multithreading programming.
Small code don’t need TDD. If the cost of TDD is higher than throwing your code away and rewrite it then you don’t need TDD.

TDD and junior teams myth:
Junior programmers have always less to forget and fewer bad habits. Junior teams benefit most from TDD while experience programmers have to forget some of their bad habits.

A TDD example

Let’s code and design a simple stack using TDD. I’ll present couple of steps of the process but not the final implementation. First we have to answer to the most mind boggling question of a programmer:

Who was first the test or the code?

Of course the answer is THE TEST! Remember the first step of the TDD cycle, write the simplest test that fails.

So our test class is StackTest and our first method is testEmptyStack:

import static junit.framework.Assert.assertEquals;
import org.junit.Test;

public class StackTest {
    @Test
    public void testEmptyStack() {
        assertEquals(0, stack.size());
    }
}

Now we have to make the test pass writing only the code required for that. I am going to use junit for the assert methods. Our stack will be named MStack to avoid the name collision with the java.util.Stack. My IDE is insisting in using that class.

    public void testEmptyStack() {
        MStack stack = new MStack();
        assertEquals(0, stack.size());
    }

Now let’s create the MStack, for the sake of simplicity I am going to use inner classes and in the end when the design is complete I’ll pull the code out:

public class StackTest {
    @Test
    public void testEmptyStack() {
        MStack stack = new MStack();
        assertEquals(0, stack.size());
    }
}
class MStack {
    public int size() {
        return 0;
    }
}

So we have written the code that make the test pass, looking of the code i see no duplicates or function names that have to rename to a better name. Let’s write the simple test that make the code fail. I say let’s test the “push”.

   @Test
    public void testPushElement() {
        MStack stack = new MStack();
        stack.push("First element");
        assertEquals(1, stack.size());
    }

Add the push method and run the test to see them fail:

junit.framework.AssertionFailedError: expected:<1> but was:<0>
	at org.bserban.tdd.StackTest.testPushElement(StackTest.java:16)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

Now write the simplest code that make the code pass the tests, remember the rules!

Add code on red, delete code on green!

class MStack {
    private boolean elementAdded;
    public int size() {
        if (elementAdded) {
            return 1;
        }
        return 0;
    }
    public void push(String element) {
        elementAdded = true;
    }
}
Run the tests:
Process finished with exit code 0

The code above could look stupid but this is the essence of the test driven design, remember experience programmers have a lot to forget , they are not willing to code in such manner until the see the true benefit of such approach. The problem we choose is trivial and for people with experience this way to code sounds silly. I’ll add two new asserts that make the code fail the tests.

    @Test
    public void testPushElement() {
        MStack stack = new MStack();
        stack.push("First element");
        assertEquals(1, stack.size());
        stack.push("Second element");
        assertEquals(2, stack.size());
        stack.push("Third element");
        assertEquals(3, stack.size());
    }

Process finished with exit code -1

junit.framework.AssertionFailedError: expected:<2> but was:<1>
	at org.bserban.tdd.StackTest.testPushElement(StackTest.java:19)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

Remember, don’t delete the existing code on red:

class MStack {
    private boolean elementAdded;
    private boolean secondElementAdded;
    private boolean thirdElementAdded;

    public int size() {
        if (thirdElementAdded) {
            return 3;
        }else if (secondElementAdded) {
            return 2;
        } else if(elementAdded){
                return 1;
        }
        return 0;
    }
    public void push(String element) {
        if (elementAdded) {
            if (secondElementAdded) {
                thirdElementAdded = true;
            } else {
                secondElementAdded = true;
            }
        } else {
            elementAdded = true;
        }
    }
}

Run the tests:
Process finished with exit code 0

Now we are on green and we are ready to refactor, the rules are: “Remove duplication and fix bad wording”. Studying the code above we see that elementAdded, secondElementAdded and thirdElementAdded is in fact a duplication, also from the size method we see that the last element added gives us the size.

So I say to refactor like this, let’s add a size variable and every time we push an element you increment this variable. Evrika! The code becomes cleaner and compact . I must confess that these are lines that I would be writing from the start, what a bad habit

class MStack {
    private int size = 0;
    public int size() {
        return size;
    }
    public void push(String element) {
        size++;
    }
}
Run the tests:
Process finished with exit code 0

Now we proceed with method pop in the similar mater. Write the simplest test that fails:

    @Test
    public void testPopElement() {
        MStack stack = new MStack();
        stack.push("First element");
        assertEquals(1, stack.size());
        stack.pop();
        assertEquals(0, stack.size());
    }
Run the tests:
junit.framework.AssertionFailedError: expected:<0> but was:<1>
	at org.bserban.tdd.StackTest.testPopElement(StackTest.java:29)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

We are on red, we add code, we create variable popOnce:

private boolean popOnce=false;
    public int size() {
        if (popOnce) {
            return size - 1;
        }
        return size;
    }
    public void pop() {
        popOnce = true;
    }
Run the tests:
Process finished with exit code 0

Now we add the simple test that fails, three pushes and two pops. And so on, in the end we end up with the following pop code

public class StackTest {
    @Test
    public void testEmptyStack() {
        MStack stack = new MStack();
        assertEquals(0, stack.size());
    }
    @Test
    public void testPushElement() {
        MStack stack = new MStack();
        stack.push("First element");
        assertEquals(1, stack.size());
        stack.push("Second element");
        assertEquals(2, stack.size());
        stack.push("Third element");
        assertEquals(3, stack.size());
    }
    @Test
    public void testPopElement() {
        MStack stack = new MStack();
        stack.push("First element");
        assertEquals(1, stack.size());
        stack.pop();
        assertEquals(0, stack.size());
        stack.push("First element");
        stack.push("Second element");
        stack.push("Third element");
        stack.pop();
        stack.pop();
        assertEquals(1, stack.size());
    }
}
class MStack {
    private int size = 0;
    public int size() {
        return size;
    }
    public void push(String element) {
        size++;
    }
    public void pop() {
        if (size > 0) {
            size--;
        }
    }
}
Run the tests:
Process finished with exit code 0

I think you’ve got the idea. I let you finish this implementation, I’ll just remind you the golden rules:

Add code on red
Delete code on green
Remove duplications
Fix bad names

Cheers,

How a DNS problem can put your Mysql server down

admin — Sat, 16 Jan 2010 15:10:39 +0000

Last week i was waked up from bed by the monitoring team from my company. There was a problem with my system, there was a DNS problem undergoing but as a side effect my app was down. Since it has a lot of traffic it had to be solved immediately.

I jumped to the computer and I quickly diagnosed the system. Everything was fine except the Mysql connection pool which was exhausted. The first thing that crossed my mind is that it was just a coincidence and I quickly ran show processlist to see a list of MySQL processes. The output was an infinite list of load balancer’s ip address having “login” text as status. In order to achieve high availability i am using Mysql by having a balanced ip address between two Mysql servers. The balancer runs a quick check every 5 seconds by connecting to Mysql and does a simple select on a table.

So for a particular reason the “load balancer” was not able to finish its login attempts and it was overloading my Mysql servers. While I was in the middle of the investigation the problem suddenly stopped. I was happy but somehow scared, i had no idea what the hell happened.

A quick search into Mysql documentation reveals that Mysql is doing a reverse DNS lookup which was the cause of my problems. Since the DNS server had a problem, the operation of reverse DNS was taking far more that 5 seconds to time out. This resulted in overloading the database servers. Check this explanation in the official documentation, How MySQL Uses DNS

After reading tha page I think that mysql needs this reverse DNS lookup only for its permission module and if you don’t use host names with the grant option then you are safe to disable this option. I quote here the parameter which does this:

–skip-name-resolve

Do not resolve host names when checking client connections. Use only IP numbers. If you use this option, all Host column values in the grant tables must be IP numbers or localhost. See Section 7.5.11, “How MySQL Uses DNS”.

I have been able to avoid this? Perhaps, but considering that I used MySQL in production for the first time, it is unlikely to think so.

Long live the reverse DNS, cheers!

Creating a secure JMX Agent in JDK 1.5

bserban — Sat, 31 Oct 2009 17:03:39 +0000

What is JMX?

Java Management Extension is an open technology for management, and monitoring that can be deployed wherever management and monitoring are needed. The most common use in a web application is for application management. This is very often an afterthought which results in many unmanaged application deployments.

You can monitor you application for availability and performance but in the same time you can use the JMX to manage and monitor you application from business perspective. Application’s runtime metrics can be expose through JMX, or in a service oriented architecture you could use JMX to control your services.

All good but when you start to work with JMX and JDK 1.5 soon you will discover one big limitation that was fixed in jdk 1.6 update 16 if i recall correctly:

Default RMI JMX agent for remote access opens 2 ports, one which is set by the -Dcom.sun.management.jmxremote.port=XXXX and one randomly assigned port.. What about firewalls?

JMX service url

service:jmx:rmi://hostname:port1/jndi/rmi//hostname:port2/jmxrmi

Where:

port1 is the port number on which the RMIServer and RMIConnection remote objects are exported
port2 is the port number of the RMI Registry

To access the RMIAgent you only need to know were the RMI registry is located from which to obtain the connection objects. I guess this was the reason to randomly assign the port1, but you have pretty high chances to have a firewall problem.

The solution is to replace the default agent and to create your own version of JMX Agent to provide access to RMI connection on a specific port.

JMX Architecture

There are three main components that makes the JMX possible:

Instrumentation layer, the managed beans and their resources. What you want to manage
JMX Agent, standard management agent that directly controls resources and makes them available to remote management applications. It is a mean to expose the managed beans, mbean server, monitoring, timing, relation, and class-loading services.
Remote management, permits the interaction between remote clients and the JMX Agent. There are a couple of default adapters that are built in, these are: HTTP Adapter (for viewing management data), RMI Adapter, SOAP Adapter, and SNMP Adapter.

Creating the Agent

To overcome the problems in JDK 1.5 explained above we need to create an java agent to export the RMI Registry and the RMIServer on specific ports.

This is pretty straight forward, we just need to export the RMIRegistry o a specific port, to get the MBeanServer and to create a JMXConnectorServer between those two. Then we just need to start the connector server and it is done

....................
LocateRegistry.createRegistry(port);
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
final String hostname = InetAddress.getLocalHost().getHostName();
JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://"+hostname+":"+port+"/jndi/rmi://"+hostname+":"+port+"/jmxrmi");
JMXConnectorServer cs = JMXConnectorServerFactory.newJMXConnectorServer(url, env, mbs);
cs.start();

Simple as it gets, but right now we don;t have any security in place. If we want to add SSL and authorization things will complicate a little.

Securing the Agent

To make the access secure we have to expose the RMIRegisty over the SSL. For this we need to make the following modification:

..............
SslRMIClientSocketFactory csf = new SslRMIClientSocketFactory();
SslRMIServerSocketFactory ssf = new SslRMIServerSocketFactory();
Registry registry = LocateRegistry.createRegistry(port, csf, ssf);
................

// Now specify the SSL Socket Factories:
//
// For the client side (remote)
//
env.put(RMIConnectorServer.RMI_CLIENT_SOCKET_FACTORY_ATTRIBUTE, csf);
// For the server side (local)
//
env.put(RMIConnectorServer.RMI_SERVER_SOCKET_FACTORY_ATTRIBUTE, ssf);
// For binding the JMX RMI Connector Server with the registry
// created above:
//
env.put("com.sun.jndi.rmi.factory.socket", csf);

final RMIServerImpl stub = new RMIJRMPServerImpl(port, csf, ssf, env);

final JMXConnectorServer cs =
new RMIConnectorServer(new JMXServiceURL("rmi", hostname, port),
env, stub, mbs) {
@Override
public JMXServiceURL getAddress() {
return url;
}
@Override
public synchronized void start() throws IOException {
try {
registry.bind("jmxrmi", stub);
} catch (AlreadyBoundException x) {
final IOException io = new IOException(x.getMessage());
io.initCause(x);
throw io;
}
super.start();
}
};
cs.start();

As you see we had to secure also the connection between ConnectorServer and JMX agent and for RMI server and client. Not that simple as the unsecure version. To add the authorization we just need to provide the credentials. Usually these are store in files and passed to the jmx connector server using environment variables:

env.put("jmx.remote.x.password.file", pasword);
env.put("jmx.remote.x.access.file", access);

And their content:

admin password1
monitor password2
..................
admin readwrite
monitor readonly

In order that SSL connections to work we need to create a keystore. This is done using keytool and can be create like this:

keytool -genkey -keyalg RSA -keysize 1024 -dname "CN=org.bserban.www" -keystore ./jmx-demo.jks -storepass bserban

Running the Agent

java -javaagent:jmx-agent.jar -Djavax.net.ssl.trustStore=./jmx-demo.jks -Djavax.net.ssl.trustPassword=bserban -Djavax.net.ssl.keyStore=./jmx-demo.jks -Djavax.net.ssl.keyStorePassword=bserban org.abserban.jmx.agent.StartAgentStandalone

Running the Client

java -Djavax.net.ssl.trustStore=./jmx-demo.jks -Djavax.net.ssl.trustPassword=bserban -Djavax.net.ssl.keyStore=./jmx-demo.jks -Djavax.net.ssl.keyStorePassword=bserban org.abserban.jmx.client.StartClient -host:localhost -port:8787 -status:on

See the comple code from Resources section. It includes the complete java code, ant file and the keystore.

Resources

Configure Apache and Tomcat severs together

bserban — Sat, 08 Aug 2009 08:12:00 +0000

The most common way to deploy your application in the production environment is to hide the Tomcat behind Apache. This has good and bad parts but it gives you a lot of flexibility and support from Apache. There are a couple of alternatives to put these two severs together:

mod_jk, this is the old connector developed under the Tomcat project and it is using the Tomcat’s AJP protocol. It is expected to be faster than the HTTP protocol which is text based.
mod_proxy, is the support module for HTTP protocol. It is TCP based and uses the HTTP which is plain text. When a web client makes a request to Apache, the Apache will make the same call to the Tomcat and then the Tomcat’s response is passed back to the web client. This connector is part of the Apache for a very long time and it is available also for older versions of Apache. This is the simplest way to put the Apache in front of a Tomcat but also the slowest way to do it.
mod_proxy_ajp, is new and is part of the Apache 2.2. It is working like mod_proxy, but as the name says it is using the AJP connector for sending and getting data from Tomcat. It is using also TCP and it is expected to be faster than plain mod_proxy

Using mod_proxy

Create your own tomcat-httpd.conf file and configure the proxy:

# # Server will not close the connection after each request allowing the browser to use the same connection # KeepAlive On MaxKeepAliveRequests 100 KeepAliveTimeout 5

#
# Load mod_proxy modules
#

LoadModule proxy_module modules/mod_proxy.so

LoadModule proxy_http_module modules/mod_proxy_http.so

ProxyRequests Off
ProxyPreserveHost On
ProxyTimeout 1000
TimeOut 1000

#
# Configure the mod_proxy
#
ProxyPass / http://127.0.0.1:8080/
ProxyPassReverse / http://127.0.0.1:8080/

Include your configuration into Apache httpd.conf using Include directive:

#load Tomcat proxy configuration Include /usr/local/tomcat6/conf/tomcat-httpd.conf

Using mod_proxy_ajp

The only difference between mod_proxy and mod_proxy_ajp is that you have to load mod_proxy_ajp and proxy the request to Tomcat using the ajp protocol.

# # Load mod_proxy modules # LoadModule proxy_module modules/mod_proxy.so

LoadModule proxy_http_module modules/mod_proxy_http.so

LoadModule proxy_ajp_module modules/mod_proxy_ajp.so

ProxyRequests Off
ProxyPreserveHost On
ProxyTimeout 1000
TimeOut 1000
#
# Enable the AJP proxy
#
ProxyPass / ajp://localhost:8009/
ProxyPassReverse / ajp://localhost:8009/

Include your configuration into Apache httpd.conf using Include directive:

#load Tomcat proxy configuration Include /usr/local/tomcat6/conf/tomcat-httpd.conf

Using mod_jk

Edit your tomcat-httpd.conf file and add mod_jk configuration:
# # Load mod_jk is is not loaded already # LoadModule jk_module modules/mod_jk.so # # # JkWorkersFile /etc/httpd/conf/workers.properties JkLogFile /var/logs/httpd/mod_jk.log JkLogLevel info JkLogStampFormat "[%a %b %d %H:%M:%S %Y] " JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories JkRequestLogFormat "%w %V %T" JkMount /test/* worker1

Include your configuration into Apache httpd.conf using Include directive:

#load mod_jk configuration configuration Include /usr/local/tomcat6/conf/tomcat-httpd.conf
Now edit the workers.properties and configure your worker:
worker.list=worker1 worker.worker1.type=ajp13 worker.worker1.host=localhost worker.worker1.port=8009 worker.worker1.connection_pool_size=150 worker.worker1.connection_pool_timeout=600 worker.worker1.socket_keepalive=1

Test each configuration using Apache Benchmark tool

Apache benchmark it is a great tool for testing the above configurations. All you need is to create a typical application page that should be hit with the ab tool. This tool takes a single url and makes requests repeatedly in separates threads. The number of threads is controlled by command line arguments. It also supports keep alive connections.

For more details about Apache Benchmark check this page Apache Benchmark

For testing purposes i have created a test war which has a test.jsp page. Because what we test does not influence the processing time overall we don’t need a complete test which includes a database call or working with certain frameworks. In the end all we need is the output of an application and to test how this output reach the browser using one of the three modes explained in the section above.

The test page will include a previous post of mine which is medium size: http://www.bserban.org/2009/05/put-together-struts2-jpa-hibernate-and-spring/. I have right-clicked in the browser, chosen the view source and copy and paste the content into test.jsp. The file has 112Kb in size.

bserban-mac:~ bserban$ ls -la ~/bin/srv/apache-tomcat-5.5.27/webapps/test/test.jsp
-rw-r–r– 1 bserban staff 113698 Aug 7 09:39 /Users/bserban/bin/srv/apache-tomcat-5.5.27/webapps/test/test.jsp

I am going to hit the Tomcat and the Apache with 10,000 request using 50 threads. The ab command looks like this:

ab -k -n 10000 -c 50 http://localhost/test/test.jsp

To access directly the Tomcat i am going to hit the 8080 port. To preserve the similar enviroment and test conditions I will restart the Apache and Tomcat after each test.

Test results

The table below summarize the results obtained.

	Direct	mode_proxy	mode_proxy_ajp
Throughput	992 reg/s	667 req/s	702 req/s
Average Response Time	50 ms	75 ms	71 ms
90% Response line	75 ms	90 ms	71 ms
100% Response line	207 ms	980 ms	972 ms

As you see, the fastest connecting mode is to connect directly to tomcat using HTTP. Direct HTTP connect will server more request per second that the other modes. The second choice is mode_proxy_ajp followed very closely by the mod_proxy. However the overhead added the the Apache will leverage for real life applications because the application processing time will minimize the impact of using Apache in front of Tomcat. Probably in real world the differences between direct HTTP connect and mod_proxy_ajp will not exceed 5-10% percents in terms of throughput and average time per request. This is the price to pay for the flexibility brought by Apache, because having the Apache in front of the Tomcat will give access to the whole Apache functionality and support.

For those who want to see test results in detail, I included in the post the tests logs.

Test result trace for Tomcat HTTP

bserban-mac:~ bserban$ ab -k -n 10000 -c 50 http://localhost:8080/test/test.jsp This is ApacheBench, Version 2.3 <$Revision: 655654 $> Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 1000 requests
Completed 2000 requests
Completed 3000 requests
Completed 4000 requests
Completed 5000 requests
Completed 6000 requests
Completed 7000 requests
Completed 8000 requests
Completed 9000 requests
Completed 10000 requests
Finished 10000 requests

Server Software:        Apache-Coyote/1.1
Server Hostname:        localhost
Server Port:            8080

Document Path: /test/test.jsp
Document Length: 113678 bytes

Concurrency Level:      50
Time taken for tests:   10.079 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Keep-Alive requests:    0
Total transferred:      1139157786 bytes
HTML transferred:       1137007356 bytes
Requests per second:    992.18 [#/sec] (mean)
Time per request:       50.394 [ms] (mean)
Time per request:       1.008 [ms] (mean, across all concurrent requests)
Transfer rate:          110376.03 [Kbytes/sec] received

Connection Times (ms)
min mean[+/-sd] median   max
Connect:        0    7   7.3      5      67
Processing:     5   43 22.4     37     182
Waiting:        0   16 19.9     11     161
Total:          7   50 22.4     45     207

Percentage of the requests served within a certain time (ms)
50%     45
66%     52
75%     57
80%     61
90%     75
95%     91
98%    119
99%    147
100%    207 (longest request)

Test result trace for mod_proxy_ajp

bserban-mac:~ bserban$ ab -k -n 10000 -c 50 http://localhost/test/test.jsp This is ApacheBench, Version 2.3 <$Revision: 655654 $> Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Licensed to The Apache Software Foundation, http://www.apache.org/

Server Software:
Server Hostname: localhost
Server Port: 80

Document Path: /test/test.jsp
Document Length: 113678 bytes

Concurrency Level:      50
Time taken for tests:   14.251 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Keep-Alive requests:    0
Total transferred:      1140884936 bytes
HTML transferred:       1139000800 bytes
Requests per second:    701.70 [#/sec] (mean)
Time per request:       71.256 [ms] (mean)
Time per request:       1.425 [ms] (mean, across all concurrent requests)
Transfer rate:          78179.54 [Kbytes/sec] received

Connection Times (ms)
min mean[+/-sd] median   max
Connect:        0    7   8.3      5      87
Processing:     6   64 89.8     47     967
Waiting:        0   38 86.9     21     920
Total:          6   71 89.4     52     972

Percentage of the requests served within a certain time (ms)
50%     52
66%     58
75%     64
80%     69
90%     83
95%    115
98%    507
99%    689
100%    972 (longest request)

Test result trace for mod_proxy

Server Software:        Apache-Coyote/1.1
Server Hostname:        localhost
Server Port:            80

Document Path: /test/test.jsp
Document Length: 113678 bytes

Concurrency Level:      50
Time taken for tests:   14.985 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Keep-Alive requests:    0
Total transferred:      1140715856 bytes
HTML transferred:       1138561771 bytes
Requests per second:    667.34 [#/sec] (mean)
Time per request:       74.925 [ms] (mean)
Time per request:       1.498 [ms] (mean, across all concurrent requests)
Transfer rate:          74339.90 [Kbytes/sec] received

Connection Times (ms)
min mean[+/-sd] median   max
Connect:        0    9 10.1      5     123
Processing:     9   66 83.2     52     975
Waiting:        0   41 83.7     27     949
Total:          9   74 82.6     59     980

Percentage of the requests served within a certain time (ms)
50%     59
66%     66
75%     72
80%     76
90%     98
95%    123
98%    192
99%    675
100%    980 (longest request)

Tomcat Clustering & Java Servlet Specification

bserban — Tue, 04 Aug 2009 11:34:51 +0000

After I read more about Tomcat Clustering I realized that the main purpose of Tomcat clustering is to offer fault tolerance, failover and high availability support. I read a lot about load balancing but when it comes to Java Servlets I found out that the only choice you have in terms of balancing is to use sticky sessions. This is more a limitation that comes from Java Servlet Specification and not from Tomcat, but it make sense.

For an application to be “distributed” you have to mark it as “distributable” by add the tag in web.xml.

There are multiple ways to balance the client request to your server pool but when it comes to Java Servlet Specification you have only one choice, as the specs say:

“Within an application that is marked as distributable, all requests that are part of a session can only be handled on a single JVM at any one time.”

“You may have multiple JVMs, each handling requests from different clients concurrently for any given distributable web application”

So, I guess you can kiss goodbye the round robin and all other load balancing options, but at least Tomcat will provide you failover, scalability and high availability.

Tomcat clustering configuration

bserban — Tue, 09 Jun 2009 08:33:36 +0000

The following steps assume that you have installed a Tomcat 5.5.x bundle or latest, i only tested on 5.5.27 but is should work for other configuration as well. The network configuration apply to Linux and may vary with the distribution. It should work as is for distributions based on Red Hat.

For Tomcat clustering we have two main things to configure:

Configure the network environment for clustering (open ports, add multicast route),
Configure Tomcat clustering support.

Configure the network support for cluster

Opening Specific HTTP Ports (e.g. Port 45564, 4001)

The cluster class will start up a membership service (multicast) and a replication service (tcp unicast). See also http://www.cyberciti.biz/faq/howto-rhel-linux-open-port-using-iptables/ for a brief article on this. You will need to have root access as noted above to complete this.

Your server may or may not already have this entry. Open iptables:

> vi /etc/sysconfig/iptables

Add the following entries:

-A RH-Firewall-1-INPUT -p udp -m udp --dport 45564 -j ACCEPT
-A RH-Firewall-1-INPUT -p tcp -m tcp --dport 45564 -j ACCEPT
-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 4001 -j ACCEPT

Save and close the above file and after restart the iptables

  > /etc/init.d/iptables restart

Configure the multicast address and routes.

Clustering membership is established using very simple multicast pings. Each Tomcat instance will periodically send out a multicast ping, in the ping message the instance will broad cast its IP and TCP listen port for replication. If an instance has not received such a ping within a given timeframe, the member is considered dead.

Add route (the server’s ip address)

sudo /sbin/route add 228.0.0.4 gw 10.72.10.1 dev bond0

Edit rc.local to make the change persistent through restarts.

sudo vim /etc/rc.d/rc.local

Add this line at the end (the server’s ip address)

/sbin/route add 228.0.0.4 gw 10.72.10.1 dev bond0

Configure Tomcat to support clustering.

Application clustering with Tomcat has two steps:

Enable clustering support,
Make you application clusterizable.

Enable Tomcat clustering support

You need to enable the cluster support in Tomcat by editing the server.xml file. Open server.xml

sudo vim /usr/local/tomcat-5.5.27/conf/server.xml

Enable clustering configuration in the configuration file, notice that the default configuration is using the DeltaManager which will replicate only the session’s changes and not the entire object:

One main condition for replication to work is that your session content is serializable. Add a _jvmRoute_ to your Tomcat Engine section From

jvmRoute identifies unique a Tomcat instance in a cluster. If multiple servers are used I recommend you to use descriptive names.

Make your application clusterizable

Configuring Tomcat clustering is not enough to cluster your application. For that you need to tell Tomcat which application you want to be clusterizable. This is achieved in two ways:

by modifying the ROOT.xml (the context configuration file”
by modifying the web.xml

Enable application clustering by ROOT.xml

Edit ROOT.xml file

 sudo vim /usr/local/tomcat-5.5.27/conf/Catalina/localhost/ROOT.xml

Look for

Change it to

Enable application clustering by editing the web.xml

Edit the web.xml file

 sudo vim /usr/local/tomcat-5.5.27/webapps/ROOT/WEB-INF/web.xml

Look for:

 
	
	contextClass
	.............

Change it to:

 
	
	
	contextClass
	.............

Restart Tomcat

 cd /usr/local/tomcat-5.5.27/bin/
sudo ./shutdown.sh
sudo ./startup.sh
or if you have a init script
sudo /etc/init.d/tomcat5 restart

You need to configure all the nodes in the cluster as detailed above. Every node should have unique name provided by “jvmRoute” attribute.

Put together Struts2, JPA, Hibernate and Spring

bserban — Sun, 31 May 2009 11:02:44 +0000

This weekend I played a bit with Struts2. Obviously my first thought was to put together “fellowship of the ring” ie Struts, Spring and Hibernate. Now, we have two ways for integrating Hibernate and I’ve chosen the Java Persistence Architecture approach, because is the latest trend in terms of persistence in the J2EE landscape.

Create your domain model

For the sake of simplicity I’ll take a simple example that contains Books and Authors. A book has one or more authors while one author wrote one or more books. This looks like a many to many relationship and we want to be able to get, from one shoot, the book and its authors and for an author his entire list of books.

Book.java

package org.bserban.shs.model;

import javax.persistence.*;

import java.util.List;

@Entity

@Table(name = "book")

public class Book {

@Id

    @GeneratedValue

    private Integer id;

    private String title;

    private String publisher;

    private String keywords;

    private String ISBN13;

    private String ISBN10;

    @ManyToMany(fetch = FetchType.EAGER)

    private List<Author> authors;

........................................

Author. java

package org.bserban.shs.model;

import javax.persistence.*;

import java.util.List;

@Entity

@Table(name = "author")

public class Author {

@Id

    @GeneratedValue

    private Integer id;

    private String firstName;

    private String lastName;

    private String blog;

    @ManyToMany(mappedBy="authors",fetch = FetchType.EAGER)

    private List<Book> books;

.......................................

As you see in the code snippets above, the many to many relationship was marked with @ManyToMany annotation. We specified that the many to many relationship is mapped by Author entity too. No need to create a persistence.xml or hibernate.cfg.xml files at this moment because the whole configuration will take place in the Spring files.

Create a DAOs

First of all create a generic DAO object to keep the reference to the EntityManager and avoid duplicate code in other DAOs.

package org.bserban.shs.dao;

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

public abstract class GenericJPADAO {

private Class persistentClass;

protected EntityManager em;

@PersistenceContext
public void setEntityManager(EntityManager em) {
this.em = em;
}

public EntityManager getEntityManager() {
return em;
}

public void save(T entity) {
getEntityManager().persist(entity);
}

public void delete(T entity) {
getEntityManager().remove(entity);
}
public T getById(Object id) {
return getEntityManager().find(persistentClass, id);
}

By making a generic DAO class using java generics we are avoiding casting and using the Object class as parameter, in this way our methods will always have the proper type for their operation. While this is very easy with simple application it can become more complicated, but don’t forget that now we are building bricks that will help us to build our house, for more complicated logic we just simply create a facade class that will use our bricks.
BookDAO.java and AuthorDAO.java

package org.bserban.shs.dao;

import org.bserban.shs.model.Author;

public class AuthorDAO extends GenericJPADAO<Author,Integer> {

package org.bserban.shs.dao;

import org.bserban.shs.model.Book;

public class BookDAO extends GenericJPADAO<Book,Integer>{

These classes are empty so far but specific methods will probably be added.

Create your service layer

I am going to build also a generic service similar with the generic DAO class. For this example I only need basic operations that can be easily made generic. All I need is to create a generic interface called GenericService and ask for a type. Note that while GenericService is an interface for the DAOs I’ve done an abstract class because I wanted to add code to methods.

package org.bserban.shs.service;

import java.util.List;

public interface GenericService<T> {

    T create(T entity);

    void delete(T entity);

    T update(T entity);

    List<T> list(int page, int size);

Now, in the Services classes we need to have also a reference to the specific DAO object for that type of service. I am going to create a dao field in each class and I am going to assume that somebody will set the dao to the correct value when the service will be used.

BookService.java and AuthorService.java, their structure is identically so i will list only one here:

package org.bserban.shs.service;

import org.bserban.shs.dao.AuthorDAO;

import org.bserban.shs.model.Author;

import java.util.List;

public class AuthorService implements GenericService<Author> {

    private AuthorDAO dao;

    public Author create(Author entity) {

        dao.save(entity);

        return entity;

    public void delete(Author entity) {

        dao.delete(entity);

    public Author update(Author entity) {

        dao.save(entity);

        return entity;

    public List<Author> list(int page, int size) {

        return dao.list(page,size);

    public AuthorDAO getDao() {

        return dao;

    public void setDao(AuthorDAO dao) {

        this.dao = dao;

For the listing feature I simply added a new method in the DAOs for list, and it looks like this:

................

public List<Author> list(int page, int size) {

    Query query = this.em.createQuery("from Author order by lastName,firstName");

    query.setFirstResult((page - 1) * size);

    query.setMaxResults(size);

    return query.getResultList();

.................

public List<Book> list(int page, int size) {

    Query query = this.em.createQuery("from Book order by title");

    query.setFirstResult((page - 1) * size);

    query.setMaxResults(size);

    return query.getResultList();

..................

Create the Actions

The actions are part of the controller and they need to validate data and to provide error handling before calling the service layer. One characteristic of putting together the Spring and Struts2 is that the dependency injection is done via a constructor argument. You could do it also with setters and getters but this would expose your service class to the exterior. One could call your action via HTTP by providing a parameter with the same name of your service class which will result into an unpredictable behavior, most probably an error.

In the actions I am going to have three fields, the first is the Service reference, the second is the list of model object and the third is a solo entity used for create, update, delete.

I will only list one Action class because they are pretty similar:

public class AuthorAction extends FrontendAction {

    private GenericService<Author> service;

    private List<Author> authors;

    private Author author;

    public AuthorAction(GenericService service) {

        this.service = service;

    public String list() {

        authors=service.list(page, size);

        return SUCCESS;

    public String update() {

        service.update(author);

        return SUCCESS;

    public String create() {

        service.create(author);

        return SUCCESS;

    public String delete() {

        service.delete(author);

        return SUCCESS;

......................................

I have created a FrontendAction to put the page and size parameters, since they are a common feature of both actions. Similar, you can put here other attributes that are common for the all actions.

Now lets add our actions into struts.xml file and start to configure the Spring support. I have chosen the extension of our actions to be *.html. I also want to set the Struts2 into dev mode to debug the application if necessary. For IOC Struts2 has a property called objectFactory which let’s you to specify what is your IOC container, i set this to “spring” values. The views will be written as Freemarker templates which I consider to be a powerful template engine.

<constant name="struts.devMode" value="true"/>

<constant name="struts.action.extension" value="html"/>

<constant name="struts.objectFactory" value="spring"/>

<constant name="struts.ui.theme" value="simple"/>

<constant name="struts.ui.templateSuffix" value="ftl"/>

<constant name="struts.configuration.xml.reload" value="true"/>

Now we need to declare our actions, I’ve decided to create different name space for each action which means that the http calls will look like this: /books/….. /authors/…..

<package name="books" namespace="/books" extends="struts-default">

    <action name="list" class="bookAction" method="list">

        <result name="success" type="freemarker">/WEB-INF/pages/books/list.ftlresult>

    action>

package>

<package name="authors" namespace="/authors" extends="struts-default">

    <action name="list" class="authorAction" method="list">

        <result name="success" type="freemarker">/WEB-INF/pages/authors/list.ftlresult>

    action>

package>

For the purpose of demonstration I am providing only the listing capability, I let you code the rest. So I need to create two templates to list the entities, they are done in the same way so i am pasting only the author’s list page:

[#ftl]

<table class="listing">

    class="hed" colspan="3">List of authors

        First Name

        Last Name

        Books

    [#list authors as author]

    if author_index%2 = 0]class="bg"[/#if]>

        ${author.firstName!''}

        ${author.lastName!''}

        [#if author.books??][#list author.books as book] ${book.title}[#if book_has_next],[/#if][/#list][/#if]

    [/#list]

table>

Glue the code with Spring

This example uses Spring 2.5.5 version. I am going to separate the configuration files in two, one is for generic configuration for JPA and transactions and the second will contain our classes glued together.

My applicationContext.xml

Declare the JPA support

<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

Now declare the EntityManager bean

<bean id="entityManagerFactory"

    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

    <property name="dataSource" ref="dataSource" />

    <property name="jpaVendorAdapter">

        <bean

            class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">

            <property name="database" value="MYSQL" />

            <property name="showSql" value="true" />

        bean>

    property>

bean>

The data source used by EntityManager bean

<bean id="dataSource"

    class="org.springframework.jdbc.datasource.DriverManagerDataSource">

    <property name="driverClassName" value="com.mysql.jdbc.Driver" />

    <property name="url" value="jdbc:mysql://localhost/example" />

    <property name="username" value="example" />

    <property name="password" value="example" />

bean>

Now I need to configure the transaction manager for my classes and obviously I am going to use the one that supports annotations. The era for declarative transaction configuration has long gone.

<bean id="transactionManager"

    class="org.springframework.orm.jpa.JpaTransactionManager">

        <property name="entityManagerFactory" ref="entityManagerFactory" />

    bean>

<tx:annotation-driven transaction-manager="transactionManager" />

Let’s not forgot our objects, let’s tell Spring where is our application specific configuration file

<import resource="exampleContext.xml"/>

Now, all I need is to glue my classes together, basically our DAOs need the JPA beans, the Services need our DAOs and Struts Actions need our Services.

exampleContext.xml will contain the followings:

 <bean id="authorDao" class="org.bserban.shs.dao.AuthorDAO"/>

 <bean id="bookDAO" class="org.bserban.shs.dao.BookDAO"/>

 <bean id="authorService" class="org.bserban.shs.service.AuthorService">

     <property name="dao" ref="authorDao"/>

 bean>

 <bean id="bookService" class="org.bserban.shs.service.BookService">

     <property name="dao" ref="bookDAO"/>

 bean>

 <bean id="authorAction" scope="prototype" class="org.bserban.shs.action.AuthorAction">

     <constructor-arg ref="authorService"/>

 bean>

 <bean id="bookAction" scope="prototype" class="org.bserban.shs.action.BookAction">

     <constructor-arg ref="bookService"/>

 bean>

Now add the transaction support to our service classes. I simply need to put the @Transactional annotation at class level which means that all method from that class support transactions.

import org.springframework.transaction.annotation.Transactional;

@Transactional

public class BookService implements GenericService<Book> {

.........................

I am going to configure also the web.xml file, where I’ll put the configuration for Struts and for Spring.

    contextConfigLocation

    value>/WEB-INF/applicationContext.xmlvalue>

    struts2

    class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter

    class>

    struts2

/*

    class>org.springframework.web.context.ContextLoaderListenerclass>

Now all we need is to hit run and see if it is working. Also we are going to need some testing data.

Database tables

Putting this line into EntintyManagerFactory bean configuration will cause the generation of our database tables.

I just need to insert manually some sample data to be able to list them in the “list” pages.

Sample data:

INSERT INTO `author` (`id`,`firstName`,`lastName`,`blog`) VALUES  (1,'John','Doe','no blog'), (2,'Sam','Dune','no blog');

INSERT INTO `book` (`id`,`title`,`publisher`,`keywords`,`ISBN13`,`ISBN10`) VALUES  (1,'Some Random Title','The plublisher','random','0596517726','978-0596517724');

INSERT INTO `book_author` (`books_id`,`authors_id`) VALUES  (1,1);

Html Views

Let’s add a simple css file to give a decent look to our pages, all we need is to customize the table look&feel.

table.listing {

    text-align: center;

    font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;

    font-weight: normal;

    font-size: 11px;

    color: #fff;

    width: 280px;

    background-color: #666;

    border: 0px;

    border-collapse: collapse;

    border-spacing: 0px;

table.listing td {

    background-color: #CCC;

    color: #000;

    padding: 4px;

    text-align: left;

    border: 1px #fff solid;

table.listing td.hed {

    background-color: #666;

    color: #fff;

    padding: 4px;

    text-align: left;

    border-bottom: 2px #fff solid;

    font-size: 12px;

    font-weight: bold;

End the result:

http://localhost:8080/books/list.html

http://localhost:8080/authors/list.html

I hope I’ll have the time to continue this apps and introduce jQuery for simple actions like add/edit/delete/filter books and authors.

Cheers,

Resources

I’ll list here all the needed jars/frameworks for this sample application:

Hibernate 3.2.1 (+ deps)
archive-browsing-1.0.jar, this was needed by hibernate to work with JPA
hibernate-entity-manager-3.2.1.jar
mysql-connector-java-5.0.4.jar
jta-1.0.B.jar
persistence-api-1.0.jar
Spring 2.5.5 jar file
Struts 2.1.6 (+ deps)
struts2-spring-plugin.jar

Source code sample, you can downloaded from here Struts2, Spring, JPA, Hibernate

Key-Value Storage using MemcacheDB

bserban — Mon, 30 Mar 2009 21:08:37 +0000

What is Entity-Attribute-Value model (aka key-value storage)

This is also know as Entity-Attribute-Value model, and it is used in circumstances where the number of attributes (properties) that can be used to describe an entity is very vast but the number of attributes that will actually be used is modest.

Let’s think in terms of a database how an Entity-Attribute-Value model would look like for storing an user profile.

id	user_id	key	value
1	101	screen_name	john
2	101	first_name	John
3	101	last_name	Smith

The table has one row for each Attribute-Value pair. In practice, we prefer to separate values based on data type to let the database to perform type validation checks and to support proper indexing. So programmers tend to create separate EAV tables for strings, real and integer numbers, dates, long text and BLOBS.

The benefits of such structure are:

Flexibility, there is no limit on attributes used to describe an entity. No schema redesign.
The storage is efficient on sparse data.
Easy to put the data into an XML format for interchange.

There are also some important drawbacks:

No real use of data types
Awkward use of database constraints
There are several problems in querying such a structure.

What is MemcacheDB

Memcachedb is a distributed key-value storage system designed for persistence. It is a very fast an reliable distributed storage. It includes transaction and replication. It is using Berkeley DB as persistence storage.

Why is better than a database?

Faster, no SQL engine on top of MemcacheDB
Designed for concurrency, design for millions of requests
Optimized for small data

Memcachedb is suitable for Messaging, metadata storage, Identity Management (Accounts, Profiles, Preferences, etc), index, counters, flags, etc.

The main features for Memcachedb are:

High performance read/write for a key-value based object
Rapid set/get for a key-value based object, not relational. Benchmark
will tell you the true later.
High reliable persistent storage with transaction Transaction is used to make your data more reliable
High availability data storage with replication Replication rocks! Achieve your HA, spread your read, make your transaction durable
Memcache protocol compatibility Lots of Memcached Client APIs can be used for Memcachedb, almost in any language, Perl, C, Python, Java

Storage, replication and recovery

Berkeley DB stores data quickly and easily without the overhead found in other databases. Read more about Berkeley DB here

MemcacheDB supports replication using Masters and Slaves nodes. The exact deployment design must chosen according with your application needs. A MemcacheDB environment consists intro three things:

Database files, files that store your data
Log files, all your transaction commit first into logs
Region files, back the share memory region

One problem could be spot in Log files, that record you transaction, over time they will contain a lot of data making the recovery a pain moment. For this Memcache DB has a Checkpoint. The checkpoint empties the in-memory cache, writes a checkpoint record, flushes the logs and writes a list of open database files.

Berkeley DB also allows hot backups and uses gzip and tar to compress the backup.

Monitoring

Memcache DB has a lot of built in commands for monitoring, such as:

Current status: stats
Database engine status: stats db
Replication status: stats rep

What i liked most at Memcached is that you can use telnet to log on the running process and issue commands from command prompt. The same thing is valid also for MemcacheDB.

Besides memcached built function the Berkeley DB engine comes with his own stats command:

db_stats, –c locking statistics, –l logging statistics, –m cache statistics, –r replication statistics, –t transaction statistics.

Overall i liked what i saw about this alternative and i think that this is the most suitable solution for storing user profiles and user data that don’t need to be queried. When you need to scale this is for sure a very reliable solution. Have fun!

Facebook temporarily lost data.

bserban — Thu, 12 Mar 2009 22:51:20 +0000

Last Sunday Facebook reported a data loss. We are talking about approximately 15% of users’ photos. Loosing your client’s data is the worst thing that could happen to you and reminded me what a guy said once in a tech talk: “The main rules in running an online community service are: Never lose data and never go to jail.”

Facebook has not yet made public the details of what happened but only assured users that their photos will be restored using a backup. The official report states that we are talking about a hardware failure at storage level.

First of some key facts about Facebook

Facebook is the number 5 site in the world, which means it has a huge traffic (source Alexa.com),
They have 10,000 servers including 1,800 MySQL servers (administrated only by two guys, they say),
Last October the users uploaded 10 billion pictures on Facebook and considering that they keep 4 back-up copies it means that they have to store 40 billion pictures,
2-3 Terabytes of photos are uploaded every day,
They serve 15 billion photo images per day,
Daily uploads are around 100 million photos,
The peak is about 450,000 images per second.

Based on the above numbers it means that they lost approximately 1.5 billion of pictures. Waw!

How is Facebook handling user’s images? Last year Jason Sobel, Manager of the Facebook Infrastructure Group, presented some insights about the current Facebook storage solution and the future one. We don’t know right now whether the new storage solution failed or the old one is to blame.

Writing files using the old way

They were using upload servers and stored images via NFS into a NetApp storage (last year they were planning to replace it). Each image is stored 4 times. This solution experienced heavy workload when processing metadata.

Reading files using the old way

Here all resumes to speed.

First level of Cache is done using CDN, which has a hit rate of 99.8% for profiles and 92% for the rest.
Second Level of Cache is done using Cachr for profiles which is a modified evhttpd with memcached as storage, and a File Handle Cache (lighttpd and memcached) for the rest of it to reduce metadata workload on NetApp.
NetApp storage via NFS. They tried to optimize it and to reduce the number of I/O access because of the the metadata heavy workload.

The main concerns with the above architecture are: Netapp storage is overwhelmed, they rely too much on CDNs.

Obviously when your app grows like hell, you start to think that is better to make your own toys, fully customized and optimized for your particular problem. So did Amazon back in 2001 and Google too. This is how the Facebook storage was born: Haystack

Haystack

The answer was to develop in house a distributed file system like GFS (Google File System). Haystack should run on inexpensive commodity hardware, and it should deliver high aggregate performance to a large number of clients.

Haystack is file based and stores arbitrary data in files. For 1Gb disk data file they create 1M in memory index. In this way they have one disk seek which is much better than NetApp which had 3.

The Haystack format is rather simple and efficient, Version number, Magic number (supplied by the client to prevent brute force attack), length, data, checksum. The index simply stores the Version, Photo key, Photo size, start, length.

Using a Haystack server

To write uses POST

/write/[pvid]_[key]_[magic]_[size].jpg

- writes data on disk haystack

- writes data on in memory index

To read uses GET

/[pvid]_[key]_[magic]_[size].jpg

- uses the in memory index to retrieve the offset

- reads data from the on-disk file

This simple approach allows Facebook to easily balance the reads and writes using Haystack clusters but to speed up the reads they still plan to use CDNs in areas where they don’t have datacenters and Cachr for profiles. This is their first step to create their own CDN network.

Additional readings

Needle in a haystack: efficient storage of billions of photos

Engineering[at]Facebook’s Notes

Simple MVC for Flex and AIR

bserban — Sat, 21 Feb 2009 20:29:44 +0000

This weekend I tried to make an “Air” client for search using “Adobe Community Help. I had no prior experience with Flex and AIR. My first attempt ended as a simple project for college, a spaghetti code. All examples found on the web or official documentation are based on massive use mxml code. I ended up having a glorious mxml file. Huge .

Some smart guys are telling you to split your mxml using an ActionScript file but is like putting the trash under the carpet. It is still spaghetti code but in two dishes.

I tried to remember how I would have programmed it in Java Swing. 9 years have passed since then but I remembered. TableModel, DefaultListModel, ButtonModel etc. they all came out from a dark corner of my memory. Yes ! I remembered, Swing MVC.

A typical sample from documentation…..

xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
    <mx:Panel x="10" y="10" width="350" height="200" title="Rate Customer Service">
        <mx:ComboBox id="cbxRating" x="20" y="20" width="100">
            <mx:dataProvider>
                <mx:Array>
                    <mx:String>Satisfiedmx:String>
                    <mx:String>Neutralmx:String>
                    <mx:String>Dissatisfiedmx:String>
                mx:Array>
            mx:dataProvider>
        mx:ComboBox>
        <mx:Button x="140" y="20" label="Send"/>
    mx:Panel>
mx:Application>

Who hard-codes his application in this way? In a typical application you get this stuff from files or database. But let’s see the good part, at least is giving you a hint, a ComboBox and List are accepting an Array as input.

MVC applied to Flex

First of all a briefing about MVC

Model, is the data. Manipulates the internal state and fire events when the internal state changed.
View, the visual representation for the Model’s data (controls on the screen)
Controller, is responsible for interpreting the user actions on the view and make changes to the model. (usually an event handler in flex)

In reality there is no 100% demarcation between these three layers. Is not that easy to make them completely decoupled and usually we end up making some tradeoffs.

The controller will always know about the view and the view about the controller. Controller also knows about the model. In the end I could say that the model is the only piece of the MVC that can be “100% decoupled”.

Let’s try to put a simple screen like this into MVC.

We fill in some text and then press Add. After we press add the text box is cleared and the text is added into de the list. In the end wee look into it and try to make a reusable component.

Model

The model contains the actual data, and for our example it should a class that hold list values. As I pointed out earlier we could use an ArrayCollection to store the list. For this we make an actionscript class named ListModel

The view should display model’s changes and for this we mark the model class as [Bindable]. This is nice feature of ActionScript, no such thing in Java Swing.

Now, to add a new item in the list we simply nee an addElement function. In this example we make the model a singleton. This means that if we make more than one list they will share the same data.

   1: package org.bserban.flex.simplemvc.model

   2: {

   3:     import mx.collections.ArrayCollection;

   4:     /**

   5:     * Model class used to store list data and to

   6:     * provide access to the list content.

   7:     *

   8:     * For demo purposes, we have only addElement.

   9:      */

  10:     [Bindable]

  11:     public class ListModel

  12:     {

  13:         public var items :ArrayCollection = new ArrayCollection();

  14:         private static var instance:ListModel;

  15:         public function ListModel()

  16:         {

  17:             instance=this;

  18:         }

  19:         /**

  20:          * For this demo we treat this class as singletone.

  21:          * If list is reused the component that reuse it

  22:          * must keep reference to model and controler.

  23:          */

  24:         public static function getInstance():ListModel{

  25:             if(instance == null){

  26:                 instance = new ListModel();

  27:             }

  28:             return instance;

  29:         }

  30:         /**

  31:          * Add a new element to the list, the model is bindable,

  32:          * no further actions are required, the view

  33:          * is notified automatically.

  34:          */

  35:         public function addElement(itm:String): void{

  36:             items.addItem(itm);

  37:             trace(" item added, now we have:"+items.length);

  38:         }

  39:     }

  40: }

Controller

The controller is responsible for the interaction between view and model. In our case will make the validation of the text, it doesn’t allow the view to add empty text into the list. Let’s make a new class named Controller. As an exercise add also a sort function.

The controller holds a reference to the model and provides functions to the view. In a more advanced implementation the Controller would listen for events from the view and the decides what action should do.

   1: package org.bserban.flex.simplemvc.controller

   2: {

   3:     import org.bserban.flex.simplemvc.model.ListModel

   4:     import mx.utils.StringUtil;

   5:     public class Controller

   6:     {

   7:        private var model:ListModel = ListModel.getInstance();

   8:         /**

   9:          * Glue the interaction between view and model.

  10:          */

  11:         public function Controller(){

  12:         }

  13:         /**

  14:          * add a new item into the list model.

  15:          */

  16:         public function addPerson(name:String):void

  17:         {

  18:             if(name==null || StringUtil.trim(name).length==0){

  19:                 trace("empty name");

  20:             }

  21:             else{

  22:                 model.addElement(name);

  23:            }

  24:         }

  25:     }

  26: }

View

The view is the graphical representation of the component. Usually it is a an mxml file but it can be also an actions script file for advanced programmers. It binds his data to the model and use the controller to process the view events. Let’s name it SimpleAirMVC.mxml. I added Air to its name because i decided to make an air project in Flex Builder.

   1: xml version="1.0" encoding="utf-8"?>

   2: <mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" height="226" width="235">

   3:     <mx:Script>

   4:         [CDATA[

   5:         import mx.controls.List;

   6:         import org.bserban.flex.simplemvc.model.ListModel;

   7:         import org.bserban.flex.simplemvc.controller.Controller;

8:

   9:         [Bindable]

  10:          private var model:ListModel = ListModel.getInstance();

  11:         private function clickHandler():void

  12:             {

  13:                 var controler:Controller = new Controller();

  14:                 controler.addPerson(personTxt.text);

  15:                 personTxt.text="";

  16:             }

  17:              ]]>

  18:     mx:Script>

19:

  20:     <mx:TextInput x="10" y="10" id="personTxt" text="" width="145"/>

  21:     <mx:Button x="163" y="10" label="Add" id="btnAdd" click="clickHandler()"/>

  22:     <mx:List x="10" y="40" width="218" dataProvider="{model.items}">mx:List>

  23: mx:WindowedApplication>

This a simple way to implement a MVC in a small application. Things can become more complicated if the application is big. If this is the case then you should look over Pure MVC framework or Cairngorm. They eliminate the dependencies between MVC layer by using events. It is an event driven approach.

You may download the source code here SimpleAirMVC

bogdan@j3e

Key takeaways from my TDD training sessions

A TDD example

How a DNS problem can put your Mysql server down

Creating a secure JMX Agent in JDK 1.5

What is JMX?

JMX service url

JMX Architecture

Creating the Agent

Securing the Agent

Running the Agent

Running the Client

Resources

Configure Apache and Tomcat severs together

Using mod_proxy

Using mod_proxy_ajp

Using mod_jk

Test each configuration using Apache Benchmark tool

Test results

Test result trace for Tomcat HTTP

Test result trace for mod_proxy_ajp

Test result trace for mod_proxy

Tomcat Clustering & Java Servlet Specification

Tomcat clustering configuration

Configure the network support for cluster

Opening Specific HTTP Ports (e.g. Port 45564, 4001)

Configure the multicast address and routes.

Configure Tomcat to support clustering.

Enable Tomcat clustering support

Make your application clusterizable

Enable application clustering by ROOT.xml

Enable application clustering by editing the web.xml

Further reading

Put together Struts2, JPA, Hibernate and Spring

Create your domain model

Create a DAOs

Create your service layer

Create the Actions

Glue the code with Spring

Database tables

Html Views

Resources

Key-Value Storage using MemcacheDB

What is Entity-Attribute-Value model (aka key-value storage)

What is MemcacheDB

Storage, replication and recovery

Monitoring

Further reading

Facebook temporarily lost data.

Writing files using the old way

Reading files using the old way

Haystack

Additional readings

Simple MVC for Flex and AIR

MVC applied to Flex

Model

Controller

View

Further reading