Mercurial > hg > blitz_condensed
diff src/org/dancres/jini/tools/DumpRegistry.java @ 0:3dc0c5604566
Initial checkin of blitz 2.0 fcs - no installer yet.
author | Dan Creswell <dan.creswell@gmail.com> |
---|---|
date | Sat, 21 Mar 2009 11:00:06 +0000 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/org/dancres/jini/tools/DumpRegistry.java Sat Mar 21 11:00:06 2009 +0000 @@ -0,0 +1,120 @@ +package org.dancres.jini.tools; + +import net.jini.core.discovery.LookupLocator; +import net.jini.core.lookup.ServiceRegistrar; +import net.jini.discovery.DiscoveryEvent; +import net.jini.discovery.DiscoveryListener; +import net.jini.discovery.LookupDiscovery; +import net.jini.discovery.LookupDiscoveryManager; + +import org.dancres.jini.util.DiscoveryUtil; + +import java.io.IOException; +import java.rmi.RMISecurityManager; +import java.rmi.RemoteException; +import java.util.ArrayList; + +/** + This is an example of a simple lookup via multicast. It gets of rid of + the need to be aware of static lookup information because we can "discover" + lookup services dynamically at startup. This basic implementation has + one fault which is that it only scans each LookupService it finds once + for service matches (see the comments in DiscoveryListenerImpl). We could + go to the trouble of fixing this all ourselves but there's an easier way - + ServiceDiscoveryManager. +*/ +public class DumpRegistry { + public static void main(String args[]) throws Exception { + /* + Gotta do this to enable remote class downloading + */ + System.setSecurityManager(new RMISecurityManager()); + + /* + We're going to look for all ServiceRegistrar instances in all + groups - everything we can find via a multicast + */ + String[] myGroups = LookupDiscovery.ALL_GROUPS; + LookupLocator[] myLocators = new LookupLocator[0]; + + if (args.length != 0) { + ArrayList mySpecGroups = new ArrayList(); + ArrayList mySpecLocs = new ArrayList(); + + for (int i = 0; i < args.length; i++) { + if (args[i].startsWith("jini:")) { + mySpecLocs.add(new LookupLocator(args[i])); + } else { + mySpecGroups.add(args[i]); + } + } + + myGroups = new String[mySpecGroups.size()]; + myGroups = (String[]) mySpecGroups.toArray(myGroups); + + myLocators = new LookupLocator[mySpecLocs.size()]; + myLocators = (LookupLocator[]) mySpecLocs.toArray(myLocators); + } + + try { + LookupDiscoveryManager myDiscovery = + new LookupDiscoveryManager(myGroups, myLocators, + new DiscoveryListenerImpl()); + } catch (IOException anIOE) { + System.err.println("Couldn't setup LookupDiscovery - exiting"); + anIOE.printStackTrace(System.err); + System.exit(-1); + } + + /* + The thing we need to remember about this kind of discovery is + that things take *time*. Locating a ServiceRegistrar doesn't happen + immediately and is actually being done *asynchronously* (on another + thread). So, we wait a while or, in this case, forever. Note + that, depending on implementation, this might not be necessary. + It may be enough to have an active LookupDiscovery instance if it + uses normal threads. However, we assume it uses all daemon threads. + */ + try { + Object myLock = new Object(); + + synchronized(myLock) { + myLock.wait(0); + } + } catch (InterruptedException anIE) { + System.err.println("Whoops main thread interrupted"); + } + } + + private static class DiscoveryListenerImpl implements DiscoveryListener { + public void discarded(DiscoveryEvent anEvent) { + // We don't care about these + } + + public void discovered(DiscoveryEvent anEvent) { + ServiceRegistrar[] myRegs = anEvent.getRegistrars(); + + for (int i = 0; i < myRegs.length; i++) { + + try { + ServiceRegistrar myRegistrar = myRegs[i]; + + if (myRegistrar != null) { + System.out.println("Found registrar:"); + + DiscoveryUtil.dumpRegistrar(myRegistrar); + + DiscoveryUtil.dumpContents(myRegistrar); + } + + } catch (RemoteException aRE) { + System.err.println("Couldn't talk to ServiceRegistrar"); + aRE.printStackTrace(System.err); + } catch (IOException anIOE) { + System.err.println("Whoops couldn't talk to ServiceRegistrar"); + anIOE.printStackTrace(System.err); + } + } + } + } +}