Tuesday Jun 03, 2008

Eclipse IDE GlassFish Plugin : Give us your feedback

Did you know that GlassFish community provides an Eclipse plugin for developers using Eclipse as their primary development tool ?

The plugin has been developed for a while providing basic integration with GlassFish. We now would like to make this integration more effective and useful to you to enhance your productivity when using GlassFish.


We would like to hear from developers on your experience (both positive and constructive) so that we can prioritize on making improvements. Our goal is to make life a lot easier for developers when using Eclipse with GlassFish. Community feedback is the best way we can learn how to make improvements. Of course, we also very much welcome any contributions from you to make improvements.


The plugin is available at the GlassFish Plugins Java.net Project Page.
Please send us your feedback and/or contributions at either the GlassFish users mailing list or at the GlassFish Plugins users mailing list.

Friday May 09, 2008

JavaOne 08: JavaU Bonus course on GlassFish Application Server

As part of JavaU courses offered this JavaOne, a GlassFish Application Server bonus training course was offered for free as part of a multi course deal. 

Many attended this course on Monday, May 05, 08. Arun Gupta and I  presented at this course. We are pleasantly surprised by the turn out of around 180 given that it was in the evening (6 - 9 pm), 3 hours long, and JavaOne had not yet started! :) That was surely a boost of positive energy for me.

The most interesting part of the course for me was the number of questions from the greatly interactive audience right from the get go. We answered most of the questions, even picked up an NB issue from an audience member in the web services area, and the feedback we received was mostly that the course was very helpful for the audience to understand how the product features and capabilities stacked up with their experience with other app servers such as WebLogic and JBoss.

We finished around 9.45 pm. :)

Since the printed slide deck was only a portion of the total at the time it went to print, I promised the audience that I would make this available through my blog.

So here it is. JavaU Bonus Course on GlassFish Application Server Java One 2008

So for those who find the material useful, please download GlassFish and let us know what you think. Send us your comments and questions through the GlassFish User mailing list.  


Saturday Dec 08, 2007

Excellent Article on Shoal by non-Sun authors

Just came across this excellent introductory article on Shoal clustering framework on Java.net which I believe is to be published on upcoming Tuesday going by the date posted (12/11/2007).

Noticeably, this is an article by authors that we, at the Shoal community, have not yet corresponded with. This is great news as it lets us know that there is a quiet adoption of this framework. The article lucidly explains salient aspects of Shoal's clustering approach and how easy it is to integrate it into your application/infrastructure. 

We hope this will make it even easier for users to adopt this technology.

Do send us your questions at the Shoal users mailing list.


Tuesday Aug 14, 2007

Shoal Clustering User Guide Part 1

In this series of blog entries, I will provide a guide for new users on how to use Shoal for your application.

This particular blog entry provides a Shoal Clustering 101 type basic introduction. Subsequent blogs will enable the user to get more closer to the metal on how to use this technology.

What is Shoal? 

Shoal is a technology/framework that allows consuming applications the ability to participate in a group and thereby communicate with the group, register interest in being notified of group events, and share application data across group members. These functionalities enable Shoal to be used as a clustering framework in enterprise infrastructure software while also being capable of other use cases.

Shoal's core is the Group Management Service (GMS) which provides client APIs to interact with a group while allowing group communication libraries to be integrated through a service provider interface implementation. Currently with a Jxta service provider, Shoal takes advantage of advanced Jxta features for robustness, reliability and scalability.

While Shoal itself is scalable to many instances in a group (upto 64 nodes in our tests), the scaling is always determined by the size and characteristics of the employing application/product.

Shoal Downloads  

Among the first things you want to know is where to get Shoal downloads.  

Shoal download is available here. Pick the latest zip file for the latest and greatest stable version. The zip file contains two jars of interest - the shoal-gms.jar containing Shoal's client api, GMS core implementation, and a Jxta service provider implementation,  and jxta.jar which is the Jxta peer-to-peer platform.

Shoal Documentation 

Now that you have the jars, you would need documentation to see how to integrate Shoal into your product. Shoal offers APIs to consuming applications to participate in a cluster. Shoal's JavaDocs containing the APIs are available here. In the JavaDoc, select the com.sun.enterprise.ee.cms.core package.  Look in the Description section for a simple introduction to the API.

As the Description mentions, the GMSFactory class located in the com.sun.enterprise.ee.cms.core package is the entry point for getting Shoal's Group Management Service.

Code Snippet 

The following code snippet uses the GMSFactory to start the GMS module, use the GroupManagementService reference to initialize the group, register interest in events,  join the group and the api to call when the process is ready to leave the group : 


//initializes GMS and underlying group communication provider

final GroupManagementService gms = GMSFactory.startGMSModule(serverIdentifierName, groupIdentifierName, GroupManagementService.MemberType.CORE, configProperties);

//register for group events

//register to receive notification when a process joins the group
gms.addActionFactory(new JoinNotificationActionFactoryImpl(this));

//register to receive notification when a group member leaves on a planned shutdown
gms.addActionFactory(new PlannedShutdownActionFactoryImpl(this));

//register to receive notification when a group member is suspected to have failed
gms.addActionFactory(new FailureSuspectedActionFactoryImpl(this));

//register to receive notification when a group member is confirmed failed
gms.addActionFactory(new FailureNotificationActionFactoryImpl(this));

//register to receive notification when this process is selected to perform recovery operations on a failed member's resources
gms.addActionFactory(serviceName, new FailureRecoveryActionFactoryImpl(this));

//register to receive messages from other group members to this registered component

gms.addActionFactory(new MessageActionFactoryImpl(this), componentName);

//joins the group
gms.join();
 

//leaves the group gracefully
gms.shutdown(GMSConstants.shutdownType.INSTANCE_SHUTDOWN); 

As the above code snippet shows, it is extremely easy to instrument Shoal into your application and be on the road to clustering your application and take remedial actions on occurrence of group events.

A Simple Shoal Example (sources)

Look through this example code to see the full source of a Simple Shoal Example.  Look in the runSimpleSample() method to understand steps to make Shoal an in-process component.

Questions? Comments? 

If you have questions on the above, please send your questions to the Shoal users alias: users [at] shoal [dot] dev [dot] java [dot] net or post your questions as a comment to this blog entry.

In the next blog entry, I will go a bit deeper explaining specific parts of Shoal.


Saturday Mar 31, 2007

NetBeans and GlassFish clusters:What are your needs?

We are looking for feedback from users of NetBeans and GlassFish on what they would like to see in terms of their runtime interactions through the IDE with cluster(s) in GlassFish.

Most IDEs provide the ability to work with a single instance of an application server such as GlassFish, etc.  I do not see the notion of cluster(s) in the IDEs unless I have missed something obvious. There must be various use cases wherein a developer (typically an advanced developer/deployer/tester such as a System Integrator) would need the ability to interact with a cluster through the IDE.

Clustering typically involved an environment consisting of many instances that can be located on different remote machines. Such instances are created/started/stopped/deleted on each machine by a dedicated agent process that follows instructions from an administrative server within which a cluster is a logical configuration entity while instances are physical entities. So, within the IDE, there are possibly but a few operations that can be executed/managed.

So here are some questions for which I'd appreciate responses through comments (Add more if you can think of any further):

  1. Is there indeed a need for interacting with clusters through the IDE?
  2. What problems do you see today with respect to clusters from within your IDE?
  3. If the browser based admin console of the appserver can be lauched from within the IDE would this  be sufficient to address your needs?
  4. If not, why is the IDE an important piece to help solve that problem?
  5. If interacting with cluster(s) is important, what should that interaction functionality be from within an IDE?
  6. If debugging seems like an obvious use case, would that not already be addressed by working with individual instances that are part of a cluster?
  7. What other use cases do you work with that you wish an IDE could provide when working with clusters?

Do add more questions and answers if you can think of more.

Wednesday Feb 14, 2007

Blueprints team delivers Web 2.0-based PetStore 2.0 application

The Blueprints team has delivered a brand new (early access but mostly complete)  version of the popular PetStore application.

What's different about this release is that this application demonstrates the use of latest emerging technologies (popularly called Web 2.0) and uses the more mainstream pattern preference of developers, that of a web-only application that employs the JPA for persistence. As a result, the PetStore 2.0 is a significantly lightweight yet rich web application that shows how to mesh Java EE 5 artifacts with emerging technologies such as AJAX, mashups, etc.


Petstore 2.0 can be viewed live on Sun's Developer Web site located at http://webdev1.sun.com/petstore/faces/index.jsp. The announcement of the release is located at https://blueprints.dev.java.net/servlets/NewsItemView?newsItemID=4632.


The Petstore 2.0 application demonstrates numerous Web 2.0 uses cases in the application including Ajax, Client-side mashups, Server-Side mashups, Delegated mashups, RSS news bar through ROME, File upload and much more. Petstore 2.0 is part of the Java EE 5 SDK and runs on Glassfish. The release notes for Petstore are located at https://blueprints.dev.java.net/petstore/release_notes.html.

If you are a developer looking for resources and guidelines on how to build AJAX and other web 2.0 technologies enabled Java EE apps, download the PetStore and review the code base. The code is released under the BSD license and is reusable in your apps.

You can also discuss your questions at the blueprints forum located at : http://forum.java.sun.com/forum.jspa?forumID=121 

 

About

Shreedhar Ganapathy

Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today