Let us look at the following code.

@Stateless
@Scope(ScopeType.SESSION)
@Name("Something")
public class SomethingBean implements Something {
	@Logger
	private Log log;
	@In
	StatusMessages statusMessages;
	@In
	User user;
	@In
	public String test;
	@Out
	boolean invoked = false;
	@Out
	String userName = "No name";
	public String something() {
		log.info("Something.something() action called");
		statusMessages.add("something");
		invoked = true;
		userName = user.getName();
		return test;
 	}
}

And the testClass :

public class SomethingTest extends SeamTest {
	@Test
	public void test_something() throws Exception {
		new FacesRequest() {
			@Override
			protected void invokeApplication() {
				setValue("#{user.name}", "user");
				setValue("#{Something.test}", "testValue");
		//		Contexts.getSessionContext().set("test", "testValue");
				Object result = invokeMethod("#{Something.something}");
				Object object = Contexts.getSessionContext().get("invoked");
				Assert.assertTrue((Boolean) object);
			        Assert.assertEquals(Contexts.getSessionContext().get("userName"), "user");
				Assert.assertEquals(result, "testValue");
			}
		}.run();
	}
}

Using the setValue() method of the SeamTest, we can set the property on Entity bean User. BUT when I tried to use the SetValue() method to set the ‘test’ property on ‘Something’ (Session bean ) I get the following stack trace.

java.lang.AssertionError: javax.el.PropertyNotFoundException: The class ‘org.javassist.tmp.java.lang.Object_$$_javassist_1′ does not have the property ‘test’.
at org.jboss.seam.mock.AbstractSeamTest$Request.onException(AbstractSeamTest.java:455)

Clearly Seam is trying to find the ‘test’ property on some other class “org.javassist.tmp.java.lang.Object_$$_javassist_1″.
This is the proxy class generated by Seam framework. The proxy class has the same interface as the the Session bean ‘Something’. It doesn’t have the property ‘test’, since the interface doesn’t declare the getter and setter.

The Entity bean ‘user’ is handled differently by the Seam framework: No proxy is created, thus the property can be set using

 setValue("#{user.name}", "user"); 

So if in test we cannot set the property like this for session bean, how does Seam set this in production?

Seam looks for the @In property in the corresponding Context if the property is not not specified. and if it is there in the context, it is set.

The solution is to set the property value to corresponding Context.
For example in your Seam Test you could use,

Contexts.getSessionContext().set("test", "testValue").

The other option can be to have the getter and setter for the property in the @Local Interface implemented by the Session bean. This way the getter and setter of the property is there in the proxy class generated and we can use ,
setValue(Something.test, “testValue”) to set the property from test. But this would break the injection of the property. The property wont be looked up in the context and we get the error “@In attribute requires non-null value: Something.test”

In some scenarios where property is not annotated with @In, then we can go for the previous option.

I am following the book ‘Programming Groovy’. The things I have understood regarding ‘Why’ part are

Simplicity : Groovy syntax is simple and easy. It saves a lot of code and effort thus increasing the productivity of developer if he had to do the same thing in Java.

in Java

for(int i = 0; i < 3; i++) {
System.out.println("United United..." )
}

in Groovy

3.times {
println "United United..."
}

This is just a trivial example but there are lot more things like this.

Groovy's Dynamicity : This is one reason why coding is made simpler and concepts like polymorphism and
callback patterns are made easy to implement.

class Player {
String name
int age
}
class Club {
String name
String city
}
public printNameOfTheFootballingEntity(entity) {
println "the entity with name "+ entity.name + " is related to Football"
}

player = new Player(name:"Giggs", age:35)
club = new Club(name:"ManchesterUnited", city:"Old Trafford")
printNameOfTheFootballingEntity(player)
printNameOfTheFootballingEntity(club)


Consider above code. It prints the following:

the entity with name Giggs is related to Football
the entity with name ManchesterUnited is related to Football

If you observe there is no compile time check for the presence of the property "name" in the entity. While interpreting Groovy checks for this property and if it is not there it throws the Missing Property Exception. Dynamic!! ain't it?

In Groovy you dont need to end statement with semicolon.

Closures are the piece of code blocks contains some statements. They are like fucntion pointers in C. They are infact objects in groovy and can be passed to functions as arguemts as well. Closures can do the job of callbacks.

For Example

def checkPlayer = {
println it + " is a good Striker"
}

list = ["Rooney", "Tevez" , "Berbatov" ]
list.each(checkPlayer)

The above code prints the following

Rooney is a good Striker
Tevez is a good Striker
Berbatov is a good Striker

Here 'it' represents the each single item in the list that is passed to the Closure 'checkPlayer'.

The code inside the braces is closure code acting like a callback for all the elements of the set.

The same thing in Java will be a bit more effort to code.

List list = new ArrayList();
list.add("Rooney");
list.add("Tevez");
list.add("Berbatov");

for (String player : list) {
checkPlayer(player);
}
private void checkPlayer(String player) {
System.out.println(player + "is a good Striker");
}

The examples so far shows the ease with which things can be developed with little effort but ultimately have the same result because the groovy code is compiled to bytecode which JVM understands. This can make a developer more productive and it can give more agility.

Groovy accepts almost all Java programs as it can use the Java libraries and it even extends some core Java classes as well.

For example

list.join()

This prints 'RooneyTevezBerbatov'. Groovy has added the join() method on the 'List' of Java while retaining remaining methods.

All is well. These are some reasons which are good enough for any Java developer to explore Groovy.

Now the big Question arises 'When can I use Groovy over Java?' and 'What sort of applications are targeted?

I am at the moment stuck at this question. Honestly speaking i didn't get a sufficient answer . I think this 'When' question is really important especially if some thing is improved over some other thing and you are comparing both.

Groovy scripts are interpreted at runtime, this might cause some performance overhead, which is not all that bad. You can always compile it to java bytecode to remove that performance penalty.
Other reasons may be revealed to myself after some more exposure, about what kind of applications can be created using Groovy. I will share it my next blog. But any suggestions and thoughts are always welcome!

References:
'Programming Groovy' Book

Topics revolved around Web 2.0 and RIA
I liked the session by alessandro alinone on comet(Ajax Push data to browser when ever new data is available).
http://cometdaily.com/people/alessandro_alinone/

I am new to Ajax and I thought there are lot of Real-Time web applications that are being developed based on Ajax and so it is worth looking in to these pastures.

The decription of Allesandro’s session :
Several applications require real-time data to be effective, for example financial market data visualization; online auctions; online gaming; messaging systems and social networks. The Comet paradigm, as an extension to the traditional Ajax techniques, allows any web page to receive real-time data pushed by a specialized server.

Allesandro showed examples of websites (uses the comet paradigm)of stock trading where data changes are very frequent.
Many Ajax sessions were conducted in parallel in diferent halls.

Day 2: Daring Java – Day 1

I personally liked the presentation of Dr.Holly Cummins, a performance expert IBM, UK. She gave some of her ideas and experiences about the garbage collector and some general rules like the going by the row instead of column in an Array , use of reference objects ,trade-off in increasing the heap size.

She developed some garbage collection analysis tools during her 6 years stay at IBM. This was completely new to me.

http://www4.java.no/web/show.do?page=67;303&articleid=5474

Day 3 : Daring Java – Day 2

I chose wicket track, as my affinity towards wicket took over me.
Peter Thomas from Satyam gave a session on Apache Wicket. I hoped to have an advanced session on this but this was basic and not more than what we are doing in our projects.
Peter claimed that he was a friend of Anurag and he was impressed when we said that we used the Wicket tester as well in our project. There was lot of fighting between the Wicket and JSF fans and the introductory session looked relevant as most of the attendes were not aware of the Wickets’s edge. Later on there was a workshop by Peter on using wicket with spring and hibernate.

All days apart from attending sessions:

We visited some stalls which were organised by sponsors and exhibitors. We visited CORDYS stall, which is also a dutch company. They are Amsterdam based compnay and have a branch in hyderabad. Saket and Sunil won consolation prizes from CORDYS for answering 2 questions(including one mind bending puzzle).

We can share the session videos and ppt’s once we recieve them.

conclusion:
There were some sessions by sponsers themselves which were aimed at marketing rather than any technology perspective, for example the Nokia presentation. All in all this was a great summit, which gave us chance to meet some very good people and some old friends and some new technologies.

JMatter is a software application framework. It is designed specifically for building business software applications for work groups. Variety of applications can be developed using JMatter like accounting software, software for legal firms etc.

The main advantage of JMatter applications is the massive reduction in the development time. Development time is unbelievably small when compared to traditional methods of developing software.

Let see how this is possible.

Most of the applications have a lot of common features like login dialogs, authentication etc. Developers spend most of their time in developing these common features. Technically these can be referred as Orthogonal services which are general in nature across different applications.

Some of these Orthogonal features are User Interface , Query Services like display all persons who live in a city for example, Validation, Persistence , Calendaring , Logging ,Authorization , Reporting-The ability to produce printable (PDF) reports from the information that an application manages.

JMatter comes up with most of these Orthogonal services and so developers don’t have to start from scratch. This in-turn will help to reduce developement time.

Let’s look at the architecture of JMatter framework…..

JMatter and its applications are written in Java. As we know, Model-view-Controller is the most widely used architecture, JMatter provides generic view-Controller implementation leaving the developers to work on model.

In JMatter applications all data is persisted to a back end relational database. The JMatter framework uses the Hibernate framework to communicate to back-end databases.

JMatter uses the Java Swing Toolkit to produce client applications. The overall architecture has two tiers: the client application communicates over the network to the back-end database. Multiple clients can be installed on multiple workstations, and multiple users can access the system concurrently.

JMatter framework is based on Naked Object pattern. This means, the framework auto creates the object-oriented user interface for the Model Objects that we create.

Installation:
Its very easy to install JMatter. JMatter requires J2SE 5 or later and Ant 1.6 or later.
Now download the JMatter framework zip version and unzip it and start using it.

Sample Application:
Lets look at how to create a zero code Contact Manger Application using JMatter. A typical contact manager application manages contacts of different persons and provides CRUD activities on Person.

To create a new project in JMatter, invoke the new-project-ui ant target:
$ cd jmatter
$ ant new-project-ui
Then a dialog appears asking for the project name and directory. Give the details and click OK.

JMatter creates the project directory with the following structure.

$ cd ../CM
$ ls
build.xml doc/ resources/ src/ test/

JMatter creates the above directory structure for your project, along with its own ant build file.
JMatter provides a number of universal business objects, including persons, their contact information, addresses, and businesses.

In this example application I reused the predefined implementations of Person and Business, whose
fully-qualified class names are com.u2d.type.composite.Person and com.u2d.type.composite.Business, respectively.

Before we can generate our database schema, we have to communicate to JMatter the various types of objects we would like to persist. We can do this by adding an annotation (@Persist) directly
on the model classes that we define. However in this application, since we’re using pre-existing model
classes, we do this by editing the underlying template, src/persistClasses.st, directly:

..
com.u2d.type.composite.Person
com.u2d.type.composite.Business
..

We’re now ready to generate the database schema:
$ ant schema-export

Note that, behind the scenes, JMatter generates a Hibernate database mapping file for each class, and finally asks hibernate to generate the DDL (data definition language) instructions and send them to the database.

By default JMatter uses the H2 database but we can configure it to use any database.

The Class Bar:
JMatter gives the default screen for all its applications. A class bar is present on the left side of the JMatter application screen which contains different icons like Users,roles, types , folders etc. By right clicking on these icons we can do all CRUD operations on them.All these operations are provided by JMatter pertaining to Naked Object pattern . We can also add our own model objects to the class bar after writing the classes.
We can edit src/class-list.xml to add our own Model Objects to Class Bar.

Class List


Model

com.u2d.type.composite.Person
com.u2d.type.composite.Business
com.u2d.type.composite.Folder
...

Here we have added the person object already provided by JMatter.

Running the application: run the ant target , ant run.
Login to the application with default admin (admin) login. We can also change our password. Go on to create the person objects with his contacts.

We have written 0 lines of code for this application. Makes developer’s life easy!!

JMatter provides the CRUD capabilities for Person or any other Object you develop following the Naked Object pattern. All the database operation and hibernate mappings are taken care by JMatter.

Orthogonal services like login dialog, logging, persistence , localization etc are provided by JMatter. We just need to implement the Model Objects.

Following is the example for a sample class for Object Song.

package com.u2d.mytunes;
import com.u2d.type.atom.StringEO;
import com.u2d.type.atom.ImgEO;
import com.u2d.model.AbstractComplexEObject;
import com.u2d.model.Title;
import com.u2d.list.RelationalList;
import com.u2d.persist.Persist;
@Persist
public class Album extends AbstractComplexEObject
{
private final StringEO _name = new StringEO();
private final ImgEO _cover = new ImgEO();
public static final String[] fieldOrder = {"name", "cover"};
public Album() {}
public StringEO getName() { return _name; }
public ImgEO getCover() { return _cover; }
public Title title() { return _name.title(); }
}

We can add this class to class bar and start using it. JMatter provides all the CRUD operations on it.

Now let us see what the above code (Album class.) is doing…

AbstractComplexEObject is the base class extended by all JMatter model objects.
JMatter gives us many atomic types to choose from, including types for phone numbers, social security numbers, time durations, images, email addresses, colors, and much more. StringEO is just extension to String. There are two differences between a StringEO and a TextEO: 1) StringEO are saved to the database as varchar types (limit is typically 255) whereas TextEO’s are saved as text types or some other similar large text object; and 2) StringEO editors in the GUI are text fields whereas TextEO
editors are text areas.
We can think of the EO part of the type name as being an acronym for Enhanced Object.

Conclusion:
I hope this gave you detailed introduction about JMatter.
I am still not sure how much we can use JMatter if the application complexity increases. But it is absolutely terrific for small applications for Works Groups connected by LAN. I would be glad to your experience about handling complex projects with JMatter.

references: jmatter.org
For more information visit http://www.jmatter.org.

The two most common words in Security world is Confidentiality and Integrity. Understanding these two terms is very crucial. In simple words Confidentiality means that only authorized entities can read information. Integrity means reassuring the recipient of the message that the message has not been altered since it was generated by a legitimate source.
In Public Key Cryptography
—Each user U has an encryption function E_uthat is made public.
—Each user U has a decryption function (key) Du that is non-public.
D_u(E_u(m)) = m
The encryption function E_u can be revealed without revealing the decryption function D_u
As we Know Confidentiality can be provided by Encryption . Integrity can be provided by using digital signatures.

Lets plunge into some example protocol with the famous Alice and Bob example.
Now lets look at a session establishment protocol and some attacks on it. A protocol to establish a session key K between Alice and Bob must guarantee the following two properties.

After successful protocol execution:

• Only Alice and Bob (and TTP’s involved if any. TTP is a trusted third party involved in generation of a session key) should know K.
  Alice and Bob should be assured that K is newly generated.

An Adversary can do the any of the following

• Eavesdrop on all messages sent in a protocol
  Alter all messages sent in a protocol using any information available
  Re-route any message to any principal
  Generate and insert completely new messages
  Obtain the value of the session key used in any sufficiently old previous run of the protocol
  Start any number of parallel protocol runs between any principals.

Some Encryption assumptions are involved in Encryption.
The encryption of message M with key K (shared or public) is denoted by ciphertext {M}_K

Assumptions:

• Without K or matching private key, it should be impossible to retrieve M from {M}_K
  It should be impossible to retrieve K or matching private key from {M}_K
  Without K even with knowledge of M it should be impossible to alter {M}_Kwithout being detected

Here is what the notations used in this blog mean
{K}_KAT — K is encrypted with shared key between Alice and Trent. K_AT is known to both Alice and Trent.

Here Trent is the trusted third party.
In the first step Alice sends a message to Trent saying that it wants to have a session with Bob.
Trent finds keys K_AT , K_BT, generates K at random, creates {K}_AT , {K}_BT which are the shared keys between Alice and Trent, Bob and Trent respectively.
Alice decrypts {K}_KAT to get K.. Bob decrypts {K}_KBT to get K. And from now on Alice and Bob can communicate with key K.
Now lets look at the attack on this protocol.

• Mallory(one who tries to break rules,may be a valid principal ) intercepts Alice’s message intended for Trent.

  Trent thinks Alice wants key with Mallory.

  Alice is fooled that Mallory is Bob.

  Attacker is (also) a legitimate principal.

  Here Mallory impersonates as Bob and Alice is made to believe it.

FIX FOR THE ATTACK:

This protocol binds the session key to the intended users

If Mallory tries the previous attack, then Trent will include Mallory’s identity in the encrypted part intended for Alice, so she knows the decrypted key is not shared with Bob and therefore the attack will fail

YET ANOTHER ATTACK ON THIS IMPROVED PROTOCOL

Mallory records exchange between Alice and Bob as shown in the above figure.

Mallory replays messages in subsequent run like in the second step of the protocol

Here are some points to note

• K’ is a not fresh

  But Alice does not know about this.

  K’ is known to Mallory. And Mallory can again fool Alice.

  This attack is called a replay/freshness attack.

The fix here is to challenge and expect a response so that No one can play replay attacks.

So here is the improved protocol

Alice (Bob) checks if Trent is there

• Sends random challenge to Trent

  Trent responds with a message that binds the challenge to the session key as you can see in the second step of the new protocol above.

  Alice (Bob) verify the binding before accepting the key

Since Alice (Bob) expects a different response each time, Mallory cannot replay an old response without detection

This method is called challenge-response.

NA is called the nonce and its the challenge sent by Alice to Trent and trent responds for it. So a reply is always a fresh one. Now mallory canont replay the messages like it could in the previos version of the protocol.

This brand new protocol includes 2 challenge response exchanges. One is between Alice an Trent and other is between Bob and Alice.

• Bob checks if Alice is there

  Sends challenge to A (Message 4)

  Response should be fresh (Message 5)

Friends unfortunately there is another attack on this improved protocol as well. Can You guess it???!!!!! [:)]