L’elemento <iFrame/> su Internet Explorer non supporta l’evento onLoad, che può essere utile nel caso ci volessimo registrare su tale evento per fare una certa cosa al termine del caricamento del contenuto dell’iframe stesso (ad esempio fare sparire un layer con una scritta di “caricamento in corso”).

GWT prevede un widget che fa da wrapper proprio all’elemento <iFrame/> che è com.google.gwt.user.client.ui.Frame.

Per risolvere il problema ci appoggiamo ad un evento base che Internet Explorer invece gestisce sul <iFrame/>, e cioè “readystatechange“, che ci permette di intercettare anche l’evento di “documento caricato” (readyState == “complete”).

Per fare ciò è necessario usare JSNI (javascript native interface) di GWT, simile a JNI (java native interface) di java, che ci permette di scrivere del codice nativo (javascript in questo caso) che verrà interpretato direttamente dal browser.

Ovviamente il nostro widget deve supportare l’evento anche sugli altri browser, per garantire la portabilità della nostra applicazione. Per far ciò viene anche intercettato l’evento BrowserEvent già previsto nel widget base, che funziona sugli altri browser.

Il codice seguente ci fa vedere come scrivere il nostro widget MyFrame a partire da quello base GWT.

package com.example.mywidgets;

import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.IFrameElement;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.Frame;
import com.example.myevents.IFrameLoadEvent;
import com.example.myevents.IFrameLoadHandler;

/**
 *
 * @author S.DiLoro
 * Estensione custom del Frame GWT (iFrame) che supporta la registrazione
 * all'evento di "contenuto caricato" all'interno dell'iFrame, con una gestione
 * particolare per InternetExplorer, che non supporta nativamente l'evento di "onLoad"
 */
public class MyFrame extends Frame {

    public MyFrame() {
        super();
        final IFrameElement iframe = IFrameElement.as(getElement());
        sinkEvents(Event.ONLOAD);

        // only for Internet Explorer
        registerOnReadyStateChange(iframe);
    }

    public MyFrame(String url) {
        super(url);
        final IFrameElement iframe = IFrameElement.as(getElement());
        sinkEvents(Event.ONLOAD);

        // only for Internet Explorer
        registerOnReadyStateChange(iframe);
    }

    @Override
    public void setUrl(String url) {
        super.setUrl(url);
    }

    @Override
    public void onBrowserEvent(Event event) {
        super.onBrowserEvent(event);
        if (event.getTypeInt() == Event.ONLOAD) {
            fireLoadEvent();
        }
    }

    void fireLoadEvent() {
        GWT.log("LoadEvent fired", null);
        fireEvent(
            new IFrameLoadEvent()
        );
    }

    // solo per Internet Explorer
    public native void registerOnReadyStateChange(IFrameElement iframe)/*-{
        var that = this;
        iframe.onreadystatechange = function(){
            if (document.readyState == "complete"){
                that.@com.example.mywidgets.MyFrame::fireLoadEvent()();
            }
        };
    }-*/;

    public HandlerRegistration addIFrameLoadHandler(IFrameLoadHandler handler) {
        return addHandler(handler, IFrameLoadEvent.TYPE);
    }
}

Come è possibile notare, per la gestione dell’evento ci si è appoggiati all’infrastruttura standard di GWT, che prevede la creazione di un Handler e un Event custom, con la possibilità di lanciare l’evento attraverso il metodo fireEvent(event) che viene ereditato da com.google.gwt.user.client.ui.UIObject, oggetto che sta nella catena di ereditarietà dell’oggetto Frame.

Sulla nostra classe aggiungiamo infine il metodo addIFrameLoadHandler che permette al client del nostro nuovo widget di registrare un handler sull’evento IFrameLoadEvent.

L’Handler e l’Event sono rispettivamente l’interfaccia IFrameLoadHandler e l’oggetto IFrameLoadEvent.

Di seguito il codice dell’interfaccia IFrameLoadHandler:

package com.example.myevents;

import com.google.gwt.event.shared.EventHandler;

public interface IFrameLoadHandler extends EventHandler {

    void onIFrameLoad(IFrameLoadEvent event);
}

Il codice dell’oggetto IFrameLoadEvent:

package com.example.myevents;

import com.google.gwt.event.shared.GwtEvent;
import com.google.gwt.event.shared.GwtEvent.Type;

/**
 *
 * @author S.DiLoro
 */
public class IFrameLoadEvent extends GwtEvent {

    public IFrameLoadEvent() {
        super();
    }

    public static final Type TYPE = new Type();

    @Override
    protected void dispatch(IFrameLoadHandler handler) {
        handler.onIFrameLoad(this);
    }

    @Override
    public com.google.gwt.event.shared.GwtEvent.Type getAssociatedType() {
        return TYPE;
    }
}

Per finire un esempio di codice che usa il nostro nuovo widget:

MyFrame f = new MyFrame();
f.addIFrameLoadHandler(new IFrameLoadHandler() {
    @Override
        public void onIFrameLoad(IFrameLoadEvent event) {
        //di seguito possiamo mettere il nostro codice da esegure a fronte del verificarsi dell'evento
        }
    }
);

У ExtGWT есть одна интересная компонента, позволяющая делать списки с множественным выбором элементов ListField. Она позволяет выбрать один или несколько элементов из списка с помощью комбинации клавиш Shift, Ctrl и левым кликом мышкой на элементе. То есть эмулирует поведение стандартного десктопного элемента.

Однако веб-пользователям такое повединие может быть неочевидным и неудобным. Как сделать поведение ListField более простым, а отображение более наглядным?

Один из вариантов это использование checkbox’a для визуализации каждого элемента списка с изменением поведения компонента.

Для начала определим два новых css-класса  для нового компонента

.p-fieldlist-checker {
 width: 18px;
 height: 18px;
 background-position: 2px 2px;
 background-image:url(../images/default/grid/row-check-sprite.gif);
 background-repeat: no-repeat;
 background-color: transparent;
}

.p-fieldlist-checker-on {
 background-position: -23px 2px;
}

Как видно из листинга, класс p-fieldlist-checker использует стандартное для GXT изображение чекбоксов, используемое для отобрадения таблиц. Второй класс помогает нам в выборе нужного нам изображения с помощью сдвига точки отсчёта внутри картинки.

Теперь нам нужно добавить эти стили в ListField. Для этого создадим новый класс CheckboxListField. В новом классе определим новый шаблон отображения элементов, в котором будет место для checkbox’а.

import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.widget.form.ListField;
import com.google.gwt.user.client.Element;

public class CheckboxListField<D extends ModelData> extends ListField<D> {

 @Override
 protected void onRender(Element parent, int index) {
 getListView().setSelectionModel(new CheckboxListViewSelectionModel<D>());

 setTemplate("<tpl for=\".\"><div class='x-combo-list-item'><span class='p-fieldlist-checker'> </span><span>{" + getDisplayField()
 + "}</span></div></tpl>");

 super.onRender(parent, index);
 }
}

Помимо нового шаблона мы будем использовать нашу собственную модель контроля за поведением и отображением элемента.

import java.util.List;

import com.extjs.gxt.ui.client.Style.SelectionMode;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.event.ListViewEvent;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.ListViewSelectionModel;
import com.google.gwt.user.client.Element;

public class CheckboxListViewSelectionModel<M extends ModelData> extends
 ListViewSelectionModel<M> {

 @Override
 protected void handleMouseDown(ListViewEvent<M> e) {
 if (locked)
 return;
 M sel = listStore.getAt(e.getIndex());

 if (selectionMode == SelectionMode.SINGLE) {
 if (isSelected(sel)) {
 deselect(sel);
 } else if (!isSelected(sel)) {
 select(sel, false);
 }
 } else {
 if (e.isShiftKey() && lastSelected != null) {
 int last = listStore.indexOf(lastSelected);
 int index = e.getIndex();
 int a = (last > index) ? index : last;
 int b = (last < index) ? index : last;
 select(a, b, e.isControlKey());
 lastSelected = listStore.getAt(last);
 } else if (isSelected(sel)) {
 deselect(sel);
 } else {
 select(sel, true);
 }
 }
 }

 @Override
 protected void onSelectChange(M model, boolean select) {
 List<Element> all = listView.getElements();
 if (listView.isRendered() && all.size() > 0) {
 ListStore<M> store = listView.getStore();
 int index = store.indexOf(model);
 if (index != -1 && index < all.size()) {
 Element elem = all.get(index);
 if (select) {
 listView.fly((Element) elem.getChildNodes().getItem(0))
 .addStyleName("p-fieldlist-checker-on");
 } else {
 listView.fly((Element) elem.getChildNodes().getItem(0))
 .removeStyleName("p-fieldlist-checker-on");
 }
 listView.fly(elem).removeStyleName(listView.getOverStyle());
 }
 }
 }

}

Как видно из листинга, в нашем новом классе мы переопределяем два метода:

1. handleMouseDown(ListViewEvent<M> e) – отвечает за изменение поведения элемента. Здесь определяем нужное нам поведение;
2. onSelectChange(M model, boolean select) – отвечает за изменение отображения элемента. Здесь мы определяем какие картинки для каких элементов списка будут отабражаться.

Далее, в коде просто пишем:

...
CheckboxListField<BeanModel> list = new CheckboxListField<BeanModel>();
...

и получаем ListBox с элементами, перед которыми выводится checkbox.

I you end up seeing following error or something similar while running a non-ubuntu app:

error while loading shared libraries: libstdc++.so.5: cannot open shared object file: No such file or directory

Well the reason is libstdc++.so.5 was removed in Ubuntu Karmic. Fear no follow the following simple steps to get your old application running again.

cd /tmp

wget http://security.ubuntu.com/ubuntu/pool/universe/i/ia32-libs/ia32-libs_2.7ubuntu6.1_amd64.deb

dpkg-deb -x ia32-libs_2.7ubuntu6.1_amd64.deb ia32-libs

sudo cp ia32-libs/usr/lib32/libstdc++.so.5.0.7 /usr/lib32/

cd /usr/lib32

sudo ln -s libstdc++.so.5.0.7 libstdc++.so.5

~TH

При разработке большого проекта для веба порой встаёт задача ввода и проверки данных о пользователе, включая его логин и пароль.

Пароль, как правило, вводится дважды – таков традиционный способ его проверки на корректность ввода. Как это сделать в ExtGWT (GXT)?

Ответ прост: использовать специальный Validator.

Например, он может выглядеть так

import com.extjs.gxt.ui.client.widget.form.Field;
import com.extjs.gxt.ui.client.widget.form.Validator;

public class MatchValidator implements Validator {

private Field<?> matchField;
private String message;

public MatchValidator(Field<?> matchField, String message) {
if (matchField == null)
throw new IllegalArgumentException("Match field cannot be null");

this.matchField = matchField;
this.message = message;
}

@Override
public String validate(Field<?> field, String value) {
if (matchField.getValue().equals(field.getValue()))
return null;
else
return message;
}

}

далее в коде пишем

...
TextField<String> password = new TextField<String>();
password.setPassword(true);
password.setName("password");
password.setFieldLabel("Password");
password.setEmptyText("Type user password ...");

TextField<String> verify = new TextField<String>();
verify.setPassword(true);

verify.setValidator(new MatchValidator(password, "Passwords must be equal!!!"));

verify.setFieldLabel("Verify password");
verify.setEmptyText("Retype user password...");
...

и получаем желаемое.

I was wondering how I could run a Google Web Application Project created with the wizard in eclipse (part of the google eclipse plugin) on my own tomcat server.

Well, its fairly simple.

First it should be noted that when creating the project with the wizard you should deselect the google app engine sdk. You can still run your projects on google app engine, so you just make sure that you do not use any app engine specific functionality (what I would not recommend anyway to keep your projects portable).

If this prerequisite is given, you can you can just select the project you have created (the root folder) and click Google’s red box GWT button “GWT compile project”.

Then you can go to the project folder in the eclipse workspace. One of the folders created is “war”. Create a new folder in your tomcat webapps folder and name it according to your project name eg “myproject”. Now you can copy all the contents from “war” to “myproject”.

Start tomcat and volia the application should be running.

(I am not too sure whether there might be issues in more complex projects given that google uses jetty for the debug mode that can be strated directly from eclipse)

This morning at work, I was running our GWT application with some deferred binding logic in it, and all of a sudden I got this ridiculous message:

[ERROR] Class 'mycompany.rebind.HistoryResourceGenerator' must derive from 'com.google.gwt.core.ext.Generator'
[ERROR] Failure while parsing XML
com.google.gwt.core.ext.UnableToCompleteException: (see previous log entries)
at com.google.gwt.dev.cfg.ModuleDefSchema$ObjAttrCvt.convertToArg(ModuleDefSchema.java:729)
at com.google.gwt.dev.util.xml.HandlerArgs.convertToArg(HandlerArgs.java:64)
at com.google.gwt.dev.util.xml.HandlerMethod.invokeBegin(HandlerMethod.java:214)
at com.google.gwt.dev.util.xml.ReflectiveParser$Impl.startElement(ReflectiveParser.java:257)
at com.sun.org.apache.xerces.internal.parsers.AbstractSAXParser.startElement(AbstractSAXParser.java:501)


It was running fine yesterday when I left work, and now it tells me that my generator isn’t a subclass of the GWT Generator??? Quickly pulled the source, and it’s as clear as day that my generator is properly written. Then what gives?

Searching for an explanation, I pulled the GWT’s source code, and opened com.google.gwt.dev.cfg.ModuleDefSchema and here’s the method in question:

    public Object convertToArg(Schema schema, int lineNumber, String elemName,
        String attrName, String attrValue) throws UnableToCompleteException {

      Object found = singletonsByName.get(attrValue);
      if (found != null) {
        // Found in the cache.
        //
        return found;
      }

      Class<?> foundClass = null;
      try {
        // Load the class.
        //
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        foundClass = cl.loadClass(attrValue);
        Class<? extends T> clazz = foundClass.asSubclass(fReqdSuperclass);

        T object = clazz.newInstance();
        singletonsByName.put(attrValue, object);
        return object;
      } catch (ClassCastException e) {
        Messages.INVALID_CLASS_DERIVATION.log(logger, foundClass,
            fReqdSuperclass, null);
        throw new UnableToCompleteException();
      } catch (ClassNotFoundException e) {
        Messages.UNABLE_TO_LOAD_CLASS.log(logger, attrValue, e);
        throw new UnableToCompleteException();
      } catch (InstantiationException e) {
        Messages.UNABLE_TO_CREATE_OBJECT.log(logger, attrValue, e);
        throw new UnableToCompleteException();
      } catch (IllegalAccessException e) {
        Messages.UNABLE_TO_CREATE_OBJECT.log(logger, attrValue, e);
        throw new UnableToCompleteException();
      }
    }
  }

Because the error message was from Messages.INVALID_CLASS_DERIVATION, I put a breakpoint on line 22:

Messages.INVALID_CLASS_DERIVATION.log(logger, foundClass, fReqdSuperclass, null);

and started my app in debug mode. The breakpoint hits, and I noticed that the exception object is reporting ClassCastException from JSONNull to JSONObject. I quickly clicked: The error is from the class that fetches some resource over the net and plugged in to the generator. Following this lead, I found that the server resource the class was fetching wasn’t available any more, which caused the fetcher class to fail, and consequently, the ClassCastException is propagated to the generator and eventually ModuleDefSchema.

The mysterious error message, however, has nothing to do with the real problem. I spent a lot of time thinking that my Generator is wrong, because that’s what the compiler says, but in fact, it’s not. I think the confusion can be avoided if the GWT compiler can log the actual exception object, instead of interpreting the exception for the user. That’s what they’re doing in the try/catch clause in the method shown above: the exception object “e” is not used in the case of ClassCastException…

Well, the take-home message is: don’t always trust the GWT compiler message. Also, adding log more logging to your generator classes that can be indicative to where the actual problem is.

      I finally got my score for my GWT (Graduation Writing Test). I have to say that I am very pleased and very surprised. If whoever scored my essay would only see my chats they would surely fail me. I got 11/12 and that in my book is a WOW. I really have no idea how I pulled that off, it was really early in the morning, it was cold, I had a runny nose and I had a really bad headache.

      I do have to say that most of the congratulations should go to the EOP’s GWT Workshop that made me sit through five straight hours on a Saturday morning going through what the test would be like. I learned strategies and words, I wrote a practice essay too. Thank you EOP, they really made a difference.

      My second thanks go to my commentators on my other blog, the strangers that inspired me to write. For them I practiced my writing. Thank you strangers!

      For now I’ll go celebrate and hop back on to my Misspellings Train.

Google recently announced their most ambitious project to date called Google Wave. According to Google, Wave is “what email would look like if it was invented today.”

Its an excellent video that lists down many interesting things: A must watch for UI archs.

Just to summarize few of the architecture points discussed in this (and my comments)
1. MVP pattern usage in GWT. (using gwt-presenter library probably) http://martinfowler.com/eaaDev/uiArchs.html
2. Dependency injection on client side (Google-gin (client-side) and Google-Guice(server side))
3. Event Bus (following event collaboration by martin fowler http://martinfowler.com/eaaDev/EventCollaboration.html)
4. Command Pattern (probably using gwt-dispatch)

Hope it helps.. Please share your understandings as well.

Here are the slides from the talk Matt Raible gave this week.

I’ve recently finished up a series of internal presentations focusing on learning GWT.  We have selected GWT for our UI toolkit and are building our own framework on top of it, using as many mature third party libraries as we can.  We have also already deployed products which use the Google Web Toolkit.

During the presentations one of the most common questions — if not THE most common question — was “Why GWT?”.  I will assume for the moment that it wasn’t just our JavaScript gurus asking the question, although there was a fair amount of that as well.

The Google Web Toolkit provides a wealth of tools and support that will allow us to maintain our user interface code long into the future.  Being able to code our UI in Java — our primary development language — means that our developers don’t need to shift gears to understand complex (or even simple) JavaScript when working on the interface.

Complex user interactions are worth additional scrutiny here: we currently use Ext JS for some of our Ajax-enabled products.  When using Ext JS — and I’d argue this is true of any JS library — it takes some mental effort to shift from server-side Java controllers and models to their JavaScript representations.  While there are tools to aid this, there’s no substitute for sticking with Java code across all application layers, which GWT allows.

Moreover, non-standard javascript will be a non-issue, and we can use existing tools like FindBugs and PMD to check for issues in the GWT code.  Our IDEs have very mature Java support as well.

Years down the road, a new generation of developers here at GT Nexus should be able to pick up the GWT code and use whatever new tools are available to learn our UI code and patterns and make whatever changes need to be made.  It would take more effort and time to decipher and maintain JavaScript code which performs the same function.

There are other reasons to use GWT:  the optimizing compiler, for instance, or even having the weight of Google behind the toolkit.  For me the key to using GWT was the time savings we’ll get by staying with Java from our data access layer through to the user interface.

Estou desenvolvendo um projeto utiliando Spring e GWT. Pesquisei algumas alternativas para integrar os dois e a melhor solução que encontrei foi a postada neste blog.
Porém, ainda achei esta abordagem muito complexa e procurei uma solução mais simples.  Implementei o SpringRemoteServiceServlet, utilizando um código parecido com o que encontrei neste blog para integração entre o GWT e o Guice.

package br.com.fwb.base.server.spring;

import org.springframework.beans.factory.*;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.google.gwt.user.client.rpc.*;
import com.google.gwt.user.server.rpc.*;

public class SpringRemoteServiceServlet extends RemoteServiceServlet {

	private static final long serialVersionUID = 122383530332380586L;

	@Override
	public String processCall(String payload) throws SerializationException {
		try {
			RPCRequest rpcRequest = RPC.decodeRequest(payload);

			RemoteService service = getServiceInstance(rpcRequest.getMethod()
					.getDeclaringClass());

			return RPC.invokeAndEncodeResponse(service, rpcRequest.getMethod(),
					rpcRequest.getParameters(), rpcRequest
							.getSerializationPolicy());

		} catch (IncompatibleRemoteServiceException ex) {
			return RPC.encodeResponseForFailure(null, ex);
		}
	}

	private RemoteService getServiceInstance(Class<?> declaringClass) {
		WebApplicationContext wac = WebApplicationContextUtils
				.getRequiredWebApplicationContext(getServletContext());
		AutowireCapableBeanFactory beanFactory = wac
				.getAutowireCapableBeanFactory();
		return (RemoteService) BeanFactoryUtils.beanOfType(
				(ListableBeanFactory) beanFactory, declaringClass);
	}

}

Registre o seguinte no web.xml:

	<listener>
		<listener-class>
			org.springframework.web.context.ContextLoaderListener
		</listener-class>
	</listener>

	<servlet>
		<servlet-name>springRemoteServiceServlet</servlet-name>
		<servlet-class>br.com.fwb.base.server.spring.SpringRemoteServiceServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>springRemoteServiceServlet</servlet-name>
		<url-pattern>*.rpc</url-pattern>
	</servlet-mapping>

Anote a interface do servico que será chamado com @RemoteServiceRelativePath apontando para qualquer endereco que termine com .rpc:

@RemoteServiceRelativePath("../GWT.rpc")
public interface TesteService extends RemoteService {

	void teste(String s);

}

Implemente a interface remota do GWT com um bean do Spring:

@Service
public class TesteServiceImpl implements TesteService {

	public void teste(String s) {

	}

}

Para mais informações sobre como chamar o serviço no servidor a partir de um código GWT client, vide a documentação do GWT.

Quaisquer dúvidas, entrem em contato.

Ch’ti Jug avec Didier Girard et Salvador Diaz :

GWT

Pour les développeurs java : un environnement de dev pour les développeurs permettant un web RIA, avec javascript mais sans utilisé javascript.

Le principe est simple : codé en java ; et ensuite le compilateur (GWT cross-compiler) pour générer du javascript.

pour démarrer : utiliser GWT designer (plugin payant de google) ; intéret de GWT designer : c’est du wysiwyg.
en fait ça ressemble un peu à du VB… (eeeurk)

seesmic : fait en gwt.

le javascript généré n’est pas lisible; le javascript est compilé pour qu’il soit le plus rapide et le plus optimisé possible.

il est possible d’appeller le serveur (PingService) … quand on modifie l’interface coté client GWT synchronise l’interface coté serveur.

L’appel du service vers le serveur se fait tjr en asynchrone.
GWT interdit la reflexion java.

Problème pour le dialogue entre graphiste et le développeur : le passage entre html et java est complexe. Par contre le passage entre html et xml : c’est mieux.

Le problème du monolithe : le binaire du gwt prends vite 800Ko . La solution c’est runAsync : il y a des morceaux qui sont téléchargé au fil de l’eau. le runAsync permet de charcher en partie l’ensemble de l’application.

Il existe des outils pour avoir des rapports de compilation : Story of your compile.

Ce problème du monolithe de GWT est apparut avec google wave, ou il n’était pas possible d’attendre la fin du téléchargement global.

- il y a un livre en cours (par sfeir) sur GWT.

Sometimes, at runtime, you need to detect whether the application is running in Hosted Mode or not. E.g. you might decide to enable client side logging using GWT-Log only when the application is executing in Hosted Mode. The logging should be disabled once the application is deployed.

To check whether the application is executing in Hosted Mode, use the below API:

boolean isExecutingInHostedMode = GWT.isScript();

In one of my previous posts (Adding Registry Listener in PEtALS), I spoke about adding a registry listener in PEtALS ESB. In the current article, I want to introduce how I used this feature to implement a live monitoring Web application.

Here are the different modules which are used in this Live Monitoring Tool :

1. PEtALS ESB. The standard behaviour has been customized by adding a registry listener and a routing module (to be detailled below).
2. Monitoring layer. This layer is an independant process which embeds a WS-Notification engine.
3. A WS-notification subscriber. This is the module which will receive the notifications from the monitoring layer.
4. GWT based Web application used to display monitoring data.

PEtALS ESB Extensions

Registry Listener
The role of the registry listener is to register a new monitoring endpoint into the monitoring layer when a new endpoint is available within PEtALS.

Routing Module
Since modules can be added dynamically inside the PEtALS message router, we have created a module which timestamp the messages. Once the message exchange is complete, a message exchange report is sent to the monitoring layer.

Monitoring Layer

The monitoring is in charge of creating monitoring endpoints through a management API. Once a monitoring endpoint is created, it is also exposed as a Web service. This newly created Web service exposes a WS-notification subscribe operation.
Another role of the monitoring layer is to receive raw reports from the PEtALS ESB, to process the report in order to generate a WSDM payload which will be send to subscribers.

WS-Notification subscriber

The subscriber subscribes, receives and stores notifications from the Monitoring layer. That’s all for that module ;o)

GWT Based Web application

The GWT Web application uses comet in order to display live service response time. The data used to display response time is the one received and stored into the database and of course the server part of the Web application have access to this database.

As a result, we have a really nice live Web application (live means that the chart gives real time result and is updated automatically when messages are exchanged within PEtALS Service Bus). Here are some screenshots :

Live Response Time

SLA Violation

Our client in SAN MATEO, CA,  is looking for a SENIOR WEB DEVELOPER for front-end development of next generation data modeling and visualization tools.  The ideal candidate would have expertise in front end development of complex Rich Internet Applications (RIA) and have demonstrated the ability to develop high quality enterprise software in a dynamic environment.

Responsibilities

• Develop front end of Rich Internet Applications for Java-based server products
• Analyze functional requirements and specifications through close interaction with Product Management and other team members
• Participate in product design and architectural discussions
• Write unit tests to ensure developed user interfaces meet product requirements
• Provide support to the QA and support organizations
• Provide feedback and guidance to technical writers
• Develop appropriate documentation for architectural, design, implementation and test activities.

Required Skills

• Bachelor’s degree in Computer Science (or related field of study)
• Minimum of 6 years experience with front end development of Web-based user interfaces
• Minimum of 2 years experience with front end development of rich internet applications (RIA)
• Expertise in building applications using the following technologies:  Flex 3/4, Flash Action Script, HTML, DHTML, JavaScript, JSON, CSS
• Experience with the following tools: Maven, ANT, Subversion, CVS
• Familiar with cross browser support issues and solutions as well as i18n issues and solutions
• Experience doing software development in a structured, automated, and distributed development environment including design, development, QA, and documentation.
• Strong communication skills with the ability to present technical concepts concisely to non-technical members of the team.

Nice to Have:

• Familiarity with existing data modeling tools is a plus: ER/Studio ERWin, TOAD
• Experience in building applications using any of the following technologies is a plus: JSP, Struts, JavaScript, JQuery, SEAM, GWT, Rich Faces, extjs, XML/XSLT, AIR

If you are interested, please send us your resume to raj@mindsource.com.