Mohit's Weblog

GlassFish V3 comes with an OSGI Web Container, which provides the support for development of hybrid applications.

A hybrid application is a combination of Java EE and OSGI. More information about developing a simple hybrid application can be found here.

This blog entry describes about a REST based Web Application Bundle to control OSGI Framework.

Steps for the setup:

1. Download and install latest nightly build of glassfish-v3 from here.
2. Start the server using : asadmin start-domain
3. Download the OSGI Web Container bundle form here.
       Install it by copying the downloaded jar file to glassfishv3/glassfish/domains/domain1/autodeploy-bundles directory.
4. Get the ready to install REST based OSGI Framework controller OR

The complete netbeans project is available here. The project built with netbeans generates a plain war file, to make it an OSGI bundle, we need to update the MANIFEST.MF entry. Update the generated war by using the following command:
       jar -uvfm REST_WAB.war MANIFEST.MF

5. Install the application by copying it to glassfishv3/glassfish/domains/domain1/autodeploy-bundles directory. Server log will indicate the success of installation.
6. Use your browser to access the URL : http://localhost:8080/REST_WAB
       Click on View Bundles to get the status of modules in GlassFish v3. The framework controller allows for the install/uninstall, start/stop of the OSGI bundles.

Getting the OSGI Framework Bundle Context in a REST Application:

-- get the servlet context as:
        @Context ServletContext ctx;

-- getting the org.osgi.framework.BundleContext:
         BundleContext bundleContext = (BundleContext) ctx.getAttribute("osgi-bundlecontext");

The bundleContext can be used for running the OSGI Framework related commands.

GlassFish v3 provides the Sun Java EE Engine (Java EE Service Engine), a JSR 208-compliant Java Business Integration (JBI) runtime component that connects Java EE web services to JBI components. It acts as a bridge between the Java EE and JBI runtime environments for web service providers and web service consumers.

Here are the steps for using Java EE Service Engine with Fuji(OpenESB-v3)

- Download the latest GlassFish V3, promoted build from here. (http://download.java.net/glassfish/v3/promoted/). Download glassfish-v3-b*-unix.sh or glassfish-v3-b*-windows.exe file, so that the GlassFish update tool is also available.

- Install glassfish-v3, remember to check on "Install Updatetool" checkbox, during the installation. Let's call the GlassFish install directory as GF_HOME.

- Fuji-GlassFish container is available for installation with GlassFIsh-v3 at http://download.java.net/maven/open-esb/fuji/fuji-gf-container/

- Installing the fuji-glassfish-container :
    cd $GF_HOME/glassfish
    jar -xvf ~fuji-gf-container.jar

- Start the glassfish update tool : $GF_HOME/bin/updatetool. Select Java EE Service Engine from the list of available addons and install it.

- Start domain :

     -- cd $GF_HOME/bin
     -- ./asadmin start-domain

- Deploying the Service Assembly:

     -- cp ~mySA.jar $GF_HOME/glassfish/domains/domain1/autodeploy/bundles or
     -- ./asadmin deploy ~mySA.jar

- Undeploying the Service Assembly:

     -- rm $GF_HOME/glassfish/domains/domain1/autodeploy/bundles/mySA.jar or
     -- ./asadmin undeploy mySA

Useful Links:

Java EE Service Engine Details: http://java.sun.com/developer/technicalArticles/J2EE/sunjavaee_engine/
List of available JBI components: http://download.java.net/maven/open-esb/fuji/components/installers/

The CAFE Maven Archetype is now available for creating maven based projects for Sailfin CAFE. The project created will have a maven project metadata(pom.xml) and sample code for a basic click to call CAFE Application.

Steps to start developing SailFin-CAFE applications using Netbeans and Maven CAFE Archetype :

-- Create a new project : File --> New Project
-- Under maven category, select maven project.
-- Click on Add, to add the Maven CAFE Archetype to the list of available archetypes.
-- The following archetype details can be entered:
       * GroupId : org.glassfish.cafe.archetypes
       * ArtifactId : cafe-archetype
       * Version : 1.0-SNAPSHOT
       * Repository : http://download.java.net/maven/2

-- Now, select cafe-archetype and click next.
-- Enter the project details as shown in figure

-- Click Finish to create a Maven CAFE Application.
-- Right click on the project and Build it.
-- Your cafe application is ready to be deployed !!

Developing Sailfin CAFE Application with Netbeans is easier then ever. Resolve dependencies and build the project without any hassles.

Here's a quick guide to it:

- Create a new Netbeans project : File --> New Project
- In maven category, choose Maven Web Application, you will get the following window:

click finish to create a project.
- Right click on mavenproject1 - Source Packages and select new -> Java Class, to create a new Java Class.
- Make the class as CAFE CommunicationBean, by adding the following annotation:

@CommunicationBean
public class NewClass {
}

- For resolving the missing dependency, select the tooltip next to @CommunicationBean annotation and click on Search Dependency at maven repositories.

- the following suggestion box will appear, select cafe-communication-api and select Add.

- Save the project, click on the tooltip next to @CommunicatioBean and select import org.glassfish.cafe.api.bean.CommunicationBean

- Build the project and your CAFE Application is ready !!

- Steps to install and run the App:

Now your JSP is capable of establishing SIP calls. Thanks to Sailfin CAFE, no SIP Servlets needed !!!

Here is the code you need to write:

<%
    CommunicationSession commSession = (CommunicationSession) session.getAttribute("org.glassfish.cafe.communicationsession");
    String party1 = request.getParameter("party1");
    String party2 = request.getParameter("party2");
    try {
       Conversation conv = commSession.createConversation(party1);
       conv.addParticipant(party2);
       out.println("Call started between " + party1 + "and" + party2);
    } catch (Exception e) {
       e.printStackTrace();
    }
%>

Next, you would need to add a CAFE CommunicationBean to the Application.
A simple CommunicationBean looks like:

import org.glassfish.cafe.api.bean.CommunicationBean;

@CommunicationBean
public class CafeCommsBean {
}

Your Click to Call Application is ready !!

Steps to install and run the App:

This entry demonstrates the procedure for installing OpenIMS and integrating Sailfin-CAFE with it. The attached sailfin-cafe application could then be used to establish a call between two clients registered with open-ims.

Overview

• Install OpenIMS core.
• Install Sailfin-CAFE, integrate it with OpenIMS.
  
• Register IMS clients with OpenIMS core.
• Deploy the cafe-app.
• Establish call between the clients.
  

Lets get started

Installing OpenIMS core

-- Install instructions can be found here.

Note: If you are running the DNS on the same machine as OpenIMS core, then while configuring the DNS server, edit the file /etc/dhcp3/dhclient.conf and uncomment this line: prepend domain_name_servers 127.0.0.1;

-- Start OpenIMS core components viz: pcscf, scscf, icsfc and FHoSS startup as given in the installation guide.

Setting up SailFin and SailFin-CAFE

-- Download and install SailFin from here.

-- Use SailFin CAFE promoted build 05 or latest. The download and install instructions are available here.

-- Register SailFin with OpenIMS core:

• Go to http://localhost:8080 and enter hssAdmin as username & hss as password. This will lead you to FHoSS - FOKUS Home Subscriber Server webpage.
  
• Click on create(Application Server) under the servcies tab.
  
• The server setting parameters will be: Server Name - sip:hostname:5060, DiameterFDQN - hostname, Default Handling - Session-continued.
• Attach the default_ifc to the newly created server.

IMSClient setup

-- UCT IMS Client can be dowloaded at http://uctimsclient.berlios.de/

-- OpenIMS Core has Alice and Bob as the users registered by default. Use two different IMS clients to login as Alice and Bob respectively.

Deploying test application and establishing the call

-- Download and deploy the sample application using sailfin asadmin deploy.

-- Call Establishing logic of the test App:

    public class NewServlet extends HttpServlet {      
         @Context CommunicationSession session;
                 ----------

         protected void processRequest(HttpServletRequest request, HttpServletResponse response) {

                 ----------

            Call call  = session.createCall(party1);
            call.addParticipant(party2);

                -----------

          }

    }

-- Access the url : http://localhost:8080/esswebv2

-- Enter user ids : Alice@open-ims.test  and Bob@open-ims.test

-- Click on the call button and listen the IMS Clients ringing !!

Screencast

The screencast for the complete setup can be viewed here !!

Tired of writing the complex event notifiers and the event listeners, you should no longer be.

GlassFish v3, HK2 kernel has a clean and easy way to implement the event notification mechanism. Lets start with a simple Application Event Listener. This Listener will listen to any application deployed, changed or undeployed events.

The object which we are listening should be marked as @Configured :-

@Configured

public interface SomeInterface ...{

}

Now the Listener Should implement the ConfigListener Interface.

The Listener for Application Events will look like:

@Service
public class Listener implements ConfigListener {

The object for which we are implementing the listener.
    @Inject
    private Applications allApplications; 

The Following function provides the notifications of the Event.

public UnprocessedChangeEvents changed(PropertyChangeEvent[] events) {
    final UnprocessedChangeEvents unprocessed = ConfigSupport.sortAndDispatch(events, new Changed() {

    public <T extends ConfigBeanProxy> NotProcessed changed(TYPE type, Class<T> changedType, T changedInstance) {
                switch (type) {
                    case ADD: // changedInstance was added to the parent
                        break;
                    case CHANGE: // changedInstance has mutated
                        break;
                    case REMOVE: // changedInstance was removed from the parent
                        break;
                    default:
                        break;
                }
            }
}

Whenever some Application Event Occurs all the implementors of ConfigListener which are injecting the Applications interface are notified.

GlassFish v3 has a modular and extensible architecture. Hence, it provides a lot of opportunities to add more and more functionality to it. So, why not explore its modular architecture with a simple hello world module !!!
To start with we need to be familiar with the HK2 component services and OSGi module management subsystem.
In our example we will extend the asadmin command to add our own hello command to the admin command utility.

Method Decleration:
AdminCommand is exposed by glassfish through annotation @contract, this has to be implemented in order to make use of the asadmin command. Hello command will be implemented as a service using the annotation @Service, which helps in the runtime discovery of the command.The command name is specified with the @Service annotation.

@Service(name="hello")
public class HelloCommand implements AdminCommand{
    ......
}

Command Execution:
To enable an asadmin command to run, we need to implement the execute method of the AdminCommand interface. The execute method is declared as:

public void execute(AdminCommandContext context){
   ....
}
The ActionReport which is obtained from AdminCommandContext is used to return the command status or error message to the client, hence the complete hello world execute method will be:

public void execute(AdminCommandContext context){
        ActionReport report = context.getActionReport();
        report.setMessage("Hello World !!!");
        report.setActionExitCode(ExitCode.SUCCESS);
}

Writing pom.xml for the project:

Our project structure is:
    hello.command
        |---> pom.xml
        |---> hello-command
              |--->pom.xml
              |--->src/main/java/testcomponent/HelloCommand.java

The pom.xml under hello.command is the top level pom.xml with the packaging type pom. Which will be more useful is case there are multiple modules.

pom.xml under hello-command includes:

Identification of the module.
    ....   
    <artifactId>hello-command</artifactId>
      <packaging>hk2-jar</packaging>
      <version>${pom.parent.version}</version>
      <name>Hello Command Sample</name>
    ....

Required Plugins, maven-bundle-plugin and hk2-maven-plugin, are specified as:
    ....
    <build>
        <plugins>
        <plugin>
                   <groupId>org.apache.felix</groupId>
                   <artifactId>maven-bundle-plugin</artifactId>
                    ....
        </plugin>
        <plugin>
                   <groupId>com.sun.enterprise</groupId>
                   <artifactId>hk2-maven-plugin</artifactId>
                    ....
        </plugin>
        </plugins>
    </build>
    ....

The Dependencies are mentioned as follows:
    ....
    <dependencies>
          <dependency>
            <groupId>com.sun.enterprise</groupId>
            <artifactId>hk2</artifactId>
            <version>${hk2.version}</version>
          </dependency>
          <dependency>
            <groupId>org.glassfish.common</groupId>
            <artifactId>common-util</artifactId>
            <version>3.0-SNAPSHOT</version>
          </dependency>
      </dependencies>
    ....

Playing with the example:

1. The complete example can be downloaded here.
2. Unzip the module in your favourite directory.
3. cd hello.command
4. mvn clean install
5. copy hello-command/target/hello-command-1.0-SNAPSHOT.jar to Glassfish-v3-installation-dir/modules
6. Start the server.
7. Execute the command : asadmin hello
8. Output: Hello World !!!

I hope it will be useful for the beginners like me.
Cheers !!!