A Thought a Day ...: Kedar Mhaswade's Weblog

Takes you on the tour of administrative security of GlassFish v3.[Read More]

Kudos to Kohsuke for implementing Mixins for Java.[Read More]

This tip deals with using Javadoc to document the use of custom annotation types.[Read More]

How to make vim behave when copying text from elsewhere and pasting into it ...[Read More]

svn is a better cvs except this perhaps? ...[Read More]

Use of bad code as utility code is more commonplace. Is there any place for good practices? Or should you just churn out as much code as you can? [Read More]

Use IDE for Java Development. Here is why ...[Read More]

mvn + svn = mess?[Read More]

A subtle observation about usability as an inverse function of capability of a software.[Read More]

Disclaimer: I don't think this is not obvious (at least to some) and it (this observation) might have been made by many. I just reached it independently.

Javadoc is a great tool. It helps understand the basic hierarchy of an API and its public implementation. It's no replacement for looking into the source code, however. Sometimes, it might be misleading to draw conclusions based on what normal Javadoc shows, without looking into the code. Here is an example:

The java.util.LinkedList  inherits iterator() from java.util.AbstractSequentialList, which has a concrete implementation for iterator(). This method calls listIterator() which is inherited from java.util.AbstractList.  This method in turn calls listIterator(int index) which has concrete implementation in java.util.LinkedList  itself.

Thus, calling java.util.LinkedList.iterator()  will result in calling listIterator(int) on the same instance of LinkedList.

Did LinkedList really inherit iterator() from AbstractSequentialList in that case?

It of couse inherited the Java method named iterator(), but it does not inherit (and does override) the behavior for iterator().

Conclusion: Read source code, and open source software is beneficial.

Question: Explain the communication details between Domain Admin Server, node-agents and server instances in Sun's Application Server 8.x and 9.x (GlassFish V2).

Terminology:

DAS: Domain Admin Server (One per domain) -- The process that controls the management of the entire domain.

NA: Node Agent -- Generally, one per box or Solaris container -- The process that controls the life cycle of server instances.

SI: Server Instance --  The real Java EE instances that run user applications in an enterprise.

Answer:

1. Background: The domain.xml controls the configuration. At every node-agent, there are also a few configuration files that are consulted by every NA. See NA section at docs.sun.com for details. Following are the points in time when the communication (for administration/management purpose) happens:

• DAS communicates with each NA: Only when DAS needs to know NA's running status.
• DAS communicates with each SI: When DAS needs to know SI's running status and when it needs to cascade the SI MBeans into the DAS's MBenServer.
  
• NA communicates with DAS: During initial rendezvous (which may happen during creation of NA), synchronization of the NA itself and synchronization of each SI that NA is responsible for.
• SI communicates with the DAS: Never, explicitly.

Thus, the communication is mainly driven by DAS. When the domain is created, the administration is configured to use an authentication realm named admin-realm. This realm points to what's called a FileRealm which is nothing but the implementation of a security realm implementation that uses admin-keyfile. If you see the domain's configuration, you'll find this file in config folder of that domain.

The communication happens over two channels. One is the HTTP channel and the other is RMI channel. For this purpose, there is a SynchronizationServlet and a System JMX Connector (standard in JDK 5) that is provided. Every DAS and SI, including the NA start a JMX RMI ConnectorServer that can be optionally configured to use transport layer security.

Every NA communicates with DAS multiple times, but the key points are of initial hand-shake and synchronization. The initial hand-shake is when NA makes DAS aware of its own existence and DAS correspondingly responds if it has the correct credentials. When the DAS is configured to have secure access (this is the default in enterprise profile domain), both the HTTP and JMX/RMI channels use Transport Layer Security with SSL/v3.  Note that during the initial hand-shake, the DAS knows about NA's existence alone. DAS does not release the contents of the domain's repository during this phase. This happens over HTTP channel since creation of node-agent takes the DAS's admin-port (default: 4848) as an option.

After an NA is created, the most natural step is to start that NA. This is done by executing the asadmin start-node-agent command. Since this is the first-time startup of the NA, NA syncs up with the DAS. Note that startup of NA requires the correct credentials (admin user name and admin password) to be supplied. The DAS compares them against its own admin-keyfile and the communication succeeds only when this succeeds. The NA startup also requires the master password to be provided on the command line because in order to start, the NA has to be able to unlock the security store (e.g. keystore.jks) that it synced from the DAS. Note that master password is never put on the wire! It has to be provided at the time of both DAS startup and every NA startup. For advanced use cases, there is an unattended boot scenario that is handled by using the option --savemasterpassword which should be used with care.

The reason NA needs the master password is also to pass it on to the SI's it starts (as part of start-instance or start-cluster) so that these instances are able to unlock the security store to get the primary keys and certificates. 

The NA always communicates with the DAS over JMX/RMI channel. Thus NA opens an RMI connection to the DAS where DAS is listening for RMI/JMX Connections. This is where the RMI Registry in DAS (default port 8686) comes into picture.

When the domain is created, it uses the self-signed certificate aliased s1as which is used for internal communication. This certificate is created anew every time a domain is created. The master password of a domain is what locks the server's keystore. In enterprise profile domain, NSS is used to manage the secure store, whereas in cluster profile domain, JKS manages the secure store. The semantics of the master password are unchanged in both the cases.

The Server Instances are synced with the DAS as part of either:

1. start-instance, or
2. start-cluster, or
3. start-node-agent --syncinstances procedure.

For this synchronization, they use the HTTP layer and communicate with the SynchronizationServlet that's listening for sync requests. This servlet is (of course) running in the DAS.

The server instances get the admin credentials from the node-agent process in a secure manner (using stdin). This also evident when you try to use the startserv script that's located in instance's bin folder.

The process of DAS communicating with the NA and SI's is identical in that it communicates with them over RMI/JMX in the other direction.

2. Transport Layer Security:

This is achieved when we enable the security-enabled flag on the admin-listener and jmx-connector named system on the DAS and server instances. Note that  admin-listener (HTTP/S) is started only in the DAS. There is no admin-listener in server instances.

It's of course possible to use another CA-signed certificate for this purpose. It needs additional configuration after importing those certs in the store.

3. Authentication and Credentials:

Please see: http://wiki.glassfish.java.net/attach/GlassFishAdministrationPages/admincreds.html

 

This is of course a wacky idea and the one which search engines might/should jump on . I checked the working draft for HTML 5 and could not find it there.

The idea is about search engines aiding all the HTML documents that are about a certain topic and want to intersperse hyper-links to certain terms that appear elsewhere on the web. Of course, I, as an author of a document that references such concepts or terms, don't want to waste time on finding the exact web-page that demonstrates it. The intent of such a link is to provide more information about that term anyway. Then, why not have a facility like:

• <a seref="Effective Java">Effective Java</a>

which will bring the page from your favorite search engine with "Effective Java" as your query string.

This is useful for the author because when the author does not really want to be specific to point to a known document, s/he can always make use of search engines which are supposed to provide more up-to-date information on a topic of general interest. More importantly, it examines if search relevance that search engines tout about is any good!

I told ya -- it is wacky , but I just implemented this in my previous post.

While I was getting used to IDEA IntelliJ IDE, one "feature" caught my attention. They have a way to create a "Singleton" by way of a pop-up menu. Here is the code that generates the class for this controversial and damned pattern (now that Google has a Singleton Detector ).

public class Single {
    private static Single ourInstance = new Single();

    public static Single getInstance() {
        return ourInstance;
    }

    private Single() {
    }
}

I see at least two problems with this "default" code:

1. The class should have been declared final.
2. The variable ourInstance should have been declared final.

Motivation:

Quality criterion for boilerplate code is same as that for real code (in these days of fast search engines ). Also, I am mildly surprised that it takes a lot of time for me to:
• Create a Java Interface
• Create a Class that implements that Interface with stubbed implementation for interface methods .
This is true with both NetBeans 6.0 (which means it is true with any other IDE because NetBeans is the only IDE you need, these days ) and IDEA 7.0.

Check out my GlassFish Podcast on this subject ...

 

One of the things I like about Firefox is Firebug. I wonder why Gmail has started showing this ugly red flag recently ...

 

 

I think it is ugly because it does not make sense to have it as a red flag. People who run Firebug know that there is an overhead involved with it. 

But it's the G-muscle, what can you do?