Source code: com/fetish/toolkit/FetishImpl.java

   package com.fetish.toolkit;
   
   import java.util.Hashtable;
   import java.net.*;
   import java.rmi.Remote;
   import java.rmi.RemoteException;
   import com.fetish.directory.LUSManager;
   import com.fetish.directory.Directory;
   import com.fetish.directory.SearchCriteria;
  import com.fetish.directory.SearchCriteriaInterface;
  import com.fetish.directory.tool.InterfaceEntry;
  import net.jini.core.discovery.LookupLocator;
  import net.jini.core.lookup.ServiceID;
  import net.jini.core.lookup.ServiceItem;
  import net.jini.core.lookup.ServiceRegistrar;
  import net.jini.core.lookup.ServiceRegistration;
  import net.jini.core.lookup.ServiceTemplate;
  import net.jini.core.lookup.ServiceMatches;
  import net.jini.core.entry.Entry;
  import net.jini.core.lease.Lease;
  import net.jini.lease.LeaseRenewalManager;
  
  /**
   * The Fetish Toolkit helper class.
   * This class provides with methods that allow an easy use of the Fetish
   * features, such as registering and deregistering a service and lookup
   * of Fetish services by ServiceID, attributes and/or interface/s implemented.
   */
  public class FetishImpl /*extends Fetish*/ {
  
    private Hashtable registry = null;
    private FetishLeaseRenewalManager lrm = null;
  
    /**
     * Simple constructor.
     * Sets up the internal registry and the lease renewal manager.
     */
    public FetishImpl() {
      registry = new Hashtable();
      lrm = new FetishLeaseRenewalManager( this );
    }
  
    /**
     * Obtains the FetishLeaseRenewalManager for the current toolkit class.
     * The FetishLeaseRenewalManager is a class that allows renewing of
     * Fetish leases, a feature that gives Fetish the power of being
     * self-healing.<p>A class on the service side
     * must renew the lease for the registered service.  If the lease expires
     * the service will be removed from the Fetish registry.<p>
     * If a service crashes it will eventually
     * fail to renew the lease; when it expires the service will be removed,
     * so nobody can retrieve a reference to it.  One or more listeners
     * can be set to listen for lease expiration events, so when a service
     * crashes and fails to renew its lease the listener can trigger the
     * suitable mechanisms to solve the situation (for example, reload
     * the service with the same ServiceID, notify the administrator, etc.)
     */
    private FetishLeaseRenewalManager getLrm() {
      if( lrm == null ) {
        lrm = new FetishLeaseRenewalManager( this );
      }
      return lrm;
    }
  
    /**
     * Gets the Fetish Toolkit registry of ServiceIDs and leases.
     * The Fetish Toolkit registry holds the leases for all services
     * registered using this instance of the toolkit.<br>
     * Such leases <b>must</b> be in the same JVM the service executes
     * in, so if the whole JVM crashes the leases will eventually expire.
     */
    private Hashtable getRegistry() {
      if( registry == null ) {
        registry = new Hashtable();
      }
      return registry;
    }
  
    /**
     * Obtains a reference to the Fada node given its url.
     * This reference can the be used to cancel a lease, thus deleting
     * the service it belongs to.
     * @param url The url of the node to be contacted.  It must be in the
     * form &lt;host&gt;[:&lt;port&gt;].  No protocol prefix must be used.
     */
    private static LUSManager getLUSManager( String url )
    throws RemoteException {
      try {
        try {
          // If exception occurs, it already has the protocol jini
          URL myUrl = new URL( "http://" + url );
          int port = myUrl.getPort();
          if( port == -1 ) {
            url = "jini://" + myUrl.getHost() + ":4160";
          } else {
            url = "jini://" + myUrl.getHost() + ":" + myUrl.getPort();
          }
        } catch( MalformedURLException mue ) {
        }
       LookupLocator locator = new LookupLocator( url );
       ServiceRegistrar registrar = locator.getRegistrar();
       Class[] classes = { LUSManager.class };
       ServiceTemplate template =  new ServiceTemplate(
                       null,
                       classes,
                       null
                     );
       Object lusm = registrar.lookup( template );
       return ( LUSManager )lusm;
     } catch( Exception e ) {
       throw new RemoteException( "Unable to find LUSManager\n" +
       "Reason: " + e.getMessage() );
     }
   }
 
   /**
    * Obtains a reference to the Fada node given its url.
    * This reference can the be used to cancel a lease, thus deleting
    * the service it belongs to.
    * @param url The url of the node to be contacted.  It must be in the
    * form &lt;host&gt;[:&lt;port&gt;].  No protocol prefix must be used.
    */
   private static Directory getDirectory( String url )
   throws RemoteException {
     try {
       try {
         // If exception occurs, it already has the protocol jini
         URL myUrl = new URL( "http://" + url );
         int port = myUrl.getPort();
         if( port == -1 ) {
           url = "jini://" + myUrl.getHost() + ":4160";
         } else {
           url = "jini://" + myUrl.getHost() + ":" + myUrl.getPort();
         }
       } catch( MalformedURLException mue ) {
       }
       LookupLocator locator = new LookupLocator( url );
       ServiceRegistrar registrar = locator.getRegistrar();
       Class[] classes = { Directory.class };
       ServiceTemplate template =  new ServiceTemplate(
                       null,
                       classes,
                       null
                     );
       Object dir = registrar.lookup( template );
       return ( Directory )dir;
     } catch( Exception e ) {
       throw new RemoteException( "Unable to find LUSManager\n" +
       "Reason: " + e.getMessage() );
     }
   }
 
   /**
    * Registers a service in the FADA architecture.
    * This method registers the service as a Jini service in the LUS the
    * FADA node is registered into, and keeps the Jini lease in the
    * registry for renewal or user retrieval.
    * @param url The url of the node to be contacted.  It must be in the
    * form &lt;host&gt;[:&lt;port&gt;].  No protocol prefix must be used.
    * @param sid The desired ServiceID of the service to be registered.
    * @param service The proxy for the service to be stored at FADA.
    * @param entries Array of Jini entries, defining more accurately the
    * service.  It will be used at lookup time by third parties.
    */
   public ServiceID register( 
     String url,
     ServiceID sid,
     Object service,
     Entry[] entries
     //long leaseDuration
   ) throws RemoteException {
 
     ServiceRegistration result = null;
     Hashtable registry = getRegistry();
     ServiceID resultSid = null;
     try {
       Directory lusm = getDirectory( url );
       ServiceItem serviceItem = new ServiceItem( sid, service, entries );
       result = lusm.register( serviceItem , Lease.ANY );
       //result = lusm.register( serviceItem , 30000 );
       Lease lease = result.getLease();
       resultSid = result.getServiceID();
       lrm.renewFor( lease, resultSid, url );
       RegistrationItem ri = new RegistrationItem( result, url, serviceItem );
       registry.put( resultSid, ri );
     } catch( Exception e ) {
       throw new RemoteException( e.getMessage() );
     }
     return resultSid;
   }
 
   /**
    * Registers a service whose lease has expired.
    * <br>
    * This method is provided in case the lease object can't be renewed
    * in time.  The main cause for this situation is that network delay
    * has suddenly become very long, and the Kalman filter hasn't been
    * able to estimate this very low probable situation.  The reregister
    * method will register the service again, keeping all data as if
    * has never been deregistered.
    * @param sid The ServiceID of the service proxy whose lease has expired.
    * @throws RemoteException if reregistration was not possible.
    */
   public void reregister( ServiceID sid ) throws RemoteException
   {
     RegistrationItem ri = ( RegistrationItem )registry.get( sid );
     registry.remove( sid );
     String url = ri.getUrl();
     ServiceItem serviceItem = ri.getServiceItem();
     serviceItem.serviceID = sid;
     Directory lusm = getDirectory( url );
     ServiceRegistration result = lusm.register( serviceItem , Lease.ANY );
     Lease lease = result.getLease();
     ServiceID resultSid = result.getServiceID();
     ri = new RegistrationItem(
                 result, url, serviceItem );
     registry.put( resultSid, ri );
     lrm.renewFor( lease, resultSid, url );
   }
 
   /**
    * Deletes the service identified by the ServiceID sid.
    * This method cancels the Jini lease for the service identified by
    * the ServiceID sid, thus deleting its entry in the Jini registry.
    * It also deletes the entry in the Fetish registry.
    * @param url The url of the node to be contacted.  It must be in the
    * form &lt;host&gt;[:&lt;port&gt;].  No protocol prefix must be used.
    * @param sid The ServiceID of the service to deregister.
    * @return <code>false</code> if
    * the deregistration was not possible (unexisting ServiceID,
    * already deregistered service, communication error with any of the
    * involved parties, etc); <code>true</code> otherwise.
    */
   public boolean unregister(
     String url,
     ServiceID sid
   ) throws RemoteException {
     boolean result = false;
     try {
       getDirectory( url ).unregister( sid );
       Hashtable reg = getRegistry();
       if( reg.containsKey( sid ) ) {
         RegistrationItem ri = ( RegistrationItem )registry.get( sid );
         Lease l = ri.getSr().getLease();
         reg.remove( sid );
         getLrm().cancel( l );
       }
       result = true;
     } catch( Exception e ) {
       throw new RemoteException(
         "Unable to unregister: "
         + e.getMessage()
       );
     }
     return result;
   }
 
   /**
    * Returns an array with the service proxies that match the search criteria.
    * The FADA node will return an array with all services that match the
    * search criteria.  A service matches the criteria if:<br>
    * <ul>
    * <li>It implements the interface <code>service</code> <i>and</i></li>
    * <li>It has at least one matching entry for all specified
    * <code>entries</code> <i>and</i></li>
    * <li>Its service id matches <code>sid</code></li>
    * </ul>
    * Any of the above search criteria may be null, meaning
    * match all (serves as a wildcard).
    * @param url The url of the node to be contacted.  It must be in the
    * form &lt;host&gt;[:&lt;port&gt;].  No protocol prefix must be used.
    * @param service The interface of the service we want to look for.
    * May be null.
    * @param entries The Jini Entry class array of attributes that may
    * identify a service.  May be null.
    * @param sid The Jini ServiceID of a previously registered service.
    * May be null.
    * @throws RemoteException If there was a communication error with any
    * of the intervening parties (the FADA node, the Jini LUS, the
    * physical connection itself, etc)
    */
   public static Object[] lookup( String url,
                   Class service,
                   Entry[] entries,
                   ServiceID sid
                   ) throws RemoteException {
     Object[] result = new Object[0];
     Directory dir = getDirectory( url );
     Class[] classServ = new Class[1];
     if( service != null ) {
       InterfaceEntry intEnt = new InterfaceEntry( service.getName() );
       Entry[] newEntries = null;
       if( entries == null ) {
         newEntries = new Entry[ 1 ];
         newEntries[ 0 ] = intEnt;
       } else {
         newEntries = new Entry[ entries.length + 1 ];
         for( int i = 0; i<entries.length; i++ ) {
           newEntries[i] = entries[i];
         }
         newEntries[ entries.length ] = intEnt;
       }
       entries = newEntries;
     } else {
     }
     SearchCriteriaInterface sc = new SearchCriteria(
                 null,
                 entries,
                 sid
               );    
     ServiceMatches sm = null;
     try {
       sm = dir.lookup( sc, 65536, 3600000L, 65536 );
       result = new Object[ sm.totalMatches ];
       for( int i = 0; i < sm.totalMatches ; i++ )
         result[i] = sm.items[i].service;
     } catch( Exception e ) {
     } 
     return result;
   }
 
   /**
    * Makes a logical connection between any two FADA nodes.
    * Lookup processes will span through all the graph of FADA nodes.
    * This method provides with a mechanism to connect FADA nodes to 
    * create a graph.<br>
    * After execution of this method, all searches started from this node
    * will also search the rest of the graph, and all services registered
    * into this node will be accessible from any point in the graph.
    * @param url1 The url of the node to be contacted.  It must be in the
    * form &lt;host&gt;[:&lt;port&gt;].  No protocol prefix must be used.
    * @param url2 The url of the node to be contacted.  It must be in the
    * form &lt;host&gt;[:&lt;port&gt;].  No protocol prefix must be used.
    * @throws RemoteException If there is any communication error with any
    * of the nodes.
    */
   public static boolean connect( String url1, String url2 )
   throws RemoteException {
     LUSManager l1 = getLUSManager( url1 );
     LUSManager l2 = getLUSManager( url2 );
     return l1.connect( l2 );
   }
 
   /**
    * Obtains the Jini Lease of the service identified by sid.
    * This Lease can then be administered by some other party, or be
    * cancelled.
    * <b>Warning</b>: cancelling a lease obtained by this method removes the
    * service the lease belongs to from the Jini registry, but <b>NOT</b> from
    * the Fetish registry.  This practice is dangerous and therefore
    * discouraged.
    * @param sid The Jini ServiceID of the service we want to obtain the lease
    * for
    * @ throws RemoteException If there is any communication error.
    */
   public Lease getFetishLease( ServiceID sid ) throws RemoteException {
     Hashtable registry = getRegistry();
     if( !registry.containsKey( sid ) )
       return null;
     RegistrationItem ri = ( RegistrationItem )registry.get( sid );
     ServiceRegistration sr = ri.getSr();
     Lease lease = sr.getLease();
     try {
       //getLrm().remove( lease );
     } catch( Exception e ) {
     }
     return lease;
   }
 
   /**
    * Obtains the Jini ServiceID for a registered service.
    * This ServiceID should be stored by the service for future registrations,
    * in order to maintain a consistency.
    * @param sr The Jini ServiceRegistration obtained in the register method.
    * @return The ServiceID for the registered service.
    */
   public static ServiceID getSID( ServiceRegistration sr ) {
     return sr.getServiceID();
   }
 
   private static long parseChar( char c ) {
     if( ( c >= '0' ) && ( c <= '9' ) ){
       return (long)(c-'0');
     } else {
       return (long)( 10 + (long)( c - 'a' ) );
     }
   }
 
   /**
    * Converts a string representing a ServiceID into an instance of ServiceID.
    * <br>
    * Takes a string representing a valid ServiceID and constructs a
    * ServiceID instance with it.  It won't check the string is a real
    * ServiceID, so errors may occur.
    * @param sid The String that represents the ServiceID
    * @return The ServiceID whose String representation matches the parameter
    * sid
    */
   public static ServiceID parseSid( String sid ) {
     long l1=0, l2=0;
     String strippedSid = sid.substring( 0, 8 ) + sid.substring( 9, 13 ) +
     sid.substring( 14, 18 ) + sid.substring( 19, 23 ) + sid.substring( 24, 36 );
     int i = 0;
     for( ; i<16; i++ ) {
       l1 = ( l1 << 4 ) + parseChar( strippedSid.charAt( i ) );
     }
     for( ; i<32; i++ ) {
       l2 = ( l2 << 4 ) + parseChar( strippedSid.charAt( i ) );
     }
     return new ServiceID( l1, l2 );
   }
 
   private class RegistrationItem
   {
 
     ServiceRegistration sr;
     String url;
     ServiceItem si;
 
     public RegistrationItem( ServiceRegistration sr, String url, ServiceItem si )
     {
       this.sr = sr;
       this.url = url;
       this.si = si;
     }
 
     public ServiceRegistration getSr()
     {
       return this.sr;
     }
 
     public void setSr( ServiceRegistration sr )
     {
       this.sr = sr;
     }
 
     public String getUrl()
     {
       return this.url;
     }
 
     public void setUrl( String url )
     {
       this.url = url;
     }
 
     public void setServiceItem( ServiceItem si )
     {
       this.si = si;
     }
 
     public ServiceItem getServiceItem()
     {
       return this.si;
     }
 
   }
   
 }