/*
 * Copyright 1999 by dreamBean Software,
 * All rights reserved.
 */
package smartproxy.proxies;

import java.lang.reflect.Proxy;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.ServerException;
import java.rmi.Naming;

/**
 *    This is a smart proxy wrapper that reconnects on failures
 *     
 *    Note that it is not tightly bound to the remote object interface,
 *    and can therefore be reused with any remote object(!)
 *
 *   @author Rickard 謆erg (rickard@dreambean.com)
 *   @version $Revision:$
 */
public class ReconnectProxy
   implements InvocationHandler, java.io.Serializable, LinkedProxy
{
   Object next;
   String name;

   // Constructors --------------------------------------------------
   public ReconnectProxy(Object next, String name)
   {
      this.next = next;
      this.name = name;
   }
   
   // Public --------------------------------------------------------
   public Object invoke(Object proxy,
                        Method method,
                        Object[] args)
      throws Throwable
   {
      validate();
      try
      {
         return method.invoke(next, args);
      } catch (InvocationTargetException e)
      {
         try
         {
            throw e.getTargetException();
         } catch (RemoteException ex)
         {
            next = null;
            throw ex;
         }
      }
   }
   
   public Object getNext()
   {
      return next;
   }
   
   public void setNext(Object next)
   {
      this.next = next;
   }
   
   protected void validate()
      throws RemoteException
   {
      if (next == null)
      {
         // Look it up again
         try
         {
            next = Naming.lookup(name);
         } catch (Exception e)
         {
            throw new ServerException("Could not reconnect to remote object", e);
         }
         
         // Peel off proxies until we reach the reconnect proxy
         while (Proxy.isProxyClass(next.getClass()) && 
                Proxy.getInvocationHandler(next) instanceof LinkedProxy &&
                !(Proxy.getInvocationHandler(next) instanceof ReconnectProxy))
         {
            next = ((LinkedProxy)Proxy.getInvocationHandler(next)).getNext();
         }
         // next is now the reconnect proxy - get the next one
         next = ((LinkedProxy)Proxy.getInvocationHandler(next)).getNext();
      }
   }
}