Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jboss.remoting;
  
  import  org.jboss.logging.Logger;
 import  org.jboss.util.id.GUID;
 
 import java.util.Map;

MicroRemoteClientInvoker is an abstract client part handler that implements the bulk of the heavy lifting to process a remote method and dispatch it to a remote ServerInvoker and handle the result.

Specialized Client/Server Invokers might add additional functionality as part of the invocation - such as delivering queued notifcations from a remote server by adding the notification objects during each invocation to the invocation result payload and then having the client re-dispatch the notifications locally upon receiving the return invocation result. The reason for the name micro is that this class contains only api that can be run within a J2ME envrionment.

Author(s):
Jeff Haynie
Tom Elrod
Version:
$Revision: 6226 $
 
 public abstract class MicroRemoteClientInvoker extends AbstractInvoker implements ClientInvoker
 {
    private static final Logger log = Logger.getLogger(MicroRemoteClientInvoker.class);
    private static final String LEASE_CREATION_TIMEOUT_DEFAULT = "30000";
    private boolean trace = .isTraceEnabled();
 
    protected boolean connected = false;
    private Marshaller marshaller;
    private UnMarshaller unmarshaller;
    private String dataType;
    private final Object clientLeaseLock = new Object();
    private LeasePinger leasePinger = null;
    private String invokerSessionID = new GUID().toString();
    private boolean parentFirstClassLoading = true;
    private boolean changeInvalidStateToCannotConnect = false;
    private boolean useCurrentThreadClassLoader;
 
    public MicroRemoteClientInvoker(InvokerLocator locator)
    {
       super(locator);
       init();
    }
 
    public MicroRemoteClientInvoker(InvokerLocator locatorMap configuration)
    {
       super(locatorconfiguration);
       init();
    }

   
Transport a request against a remote ServerInvoker.
 
    public Object invoke(InvocationRequest invocationReqthrows Throwable
    {
       Object returnValue = null;
       int invokeCount = 0;
 
       if () { .trace(this + "(" + (++invokeCount) + ") invoking " + invocationReq); }
 
       Marshaller marshaller = getMarshaller();
       UnMarshaller unmarshaller = getUnMarshaller();
 
       if (marshaller == null)
       {
          // try by locator (in case marshaller class name specified)
          Map map =  ?  : null;
          marshaller = MarshalFactory.getMarshaller(getLocator(), getClassLoader(), map);
          if (marshaller == null)
          {
             // need to have a marshaller, so create a default one
             marshaller = MarshalFactory.getMarshaller(getDataType(), getSerializationType());
             if (marshaller == null)
             {
                // went as far as possible to find a marshaller, will have to give up
                throw new InvalidMarshallingResource(
                   "Can not find a valid marshaller for data type: " + getDataType());
             }
             setMarshaller(marshaller);
          }
       }
 
       if (unmarshaller == null)
       {
          // creating a new classloader containing the remoting class loader (for remote classloading)
          // and the current thread's class loader.  This allows to load remoting classes as well as
          // user's classes.
          RemotingClassLoader remotingClassLoader = null;
         if ()
         {
            remotingClassLoader = new RemotingClassLoader(getClassLoader(), Thread.currentThread().getContextClassLoader());
         }
         else
         {
            remotingClassLoader = new RemotingClassLoader(Thread.currentThread().getContextClassLoader(), getClassLoader());
         }
         remotingClassLoader.setUseCurrentThreadClassLoader();
         // try by locator (in case unmarshaller class name specified)
         Map map =  ?  : null;
         unmarshaller = MarshalFactory.getUnMarshaller(getLocator(), getClassLoader(), map);
         if (unmarshaller == null)
         {
            unmarshaller = MarshalFactory.getUnMarshaller(getDataType(), getSerializationType());
            if (unmarshaller == null)
            {
               // went as far as possible to find a unmarshaller, will have to give up
               throw new InvalidMarshallingResource(
                  "Can not find a valid unmarshaller for data type: " + getDataType());
            }
         }
         unmarshaller.setClassLoader(remotingClassLoader);
         
         if (!)
         {
            setUnMarshaller(unmarshaller);
         }
      }
      // if raw, then send only param of invocation request
      Object payload = null;
      Map metadata = invocationReq.getRequestPayload();
      if (metadata != null && metadata.get(.) != null)
      {
         payload = invocationReq.getParameter();
      }
      else
      {
         payload = invocationReq;
      }
      returnValue =
         transport(invocationReq.getSessionId(), payloadmetadatamarshallerunmarshaller);
      // Now check if is remoting response and process
      if (returnValue instanceof InvocationResponse)
      {
         InvocationResponse response = (InvocationResponse)returnValue;
         returnValue = response.getResult();
         // if is a server side exception, throw it
         if (response.isException())
         {
            Throwable e = (Throwable)returnValue;
            if () { .trace(this + " received a server-side exception as response to the invocation: " + e); }
            StackTraceElement[] serverStackTrace;
            if (e.getCause() != null)
            {
               serverStackTrace = e.getCause().getStackTrace();
               if (serverStackTrace == null || serverStackTrace.length == 0)
               {
                  serverStackTrace = e.getStackTrace();
               }
            }
            else
            {
               serverStackTrace = e.getStackTrace();
            }
            // need to check that there is a server stack trace.  If there is not, need to log
            // warning here so caller knows that error happened on server side and to look there,
            // as stack trace is just going to lead them to here, giving the impression that is
            // a client side exception from this point within remoting client.
            if (serverStackTrace == null || serverStackTrace.length == 0)
            {
               .warn("An exception occurred on the server side when making remote invocation.  " +
                        "The exception returned from server does not include a stack trace.  " +
                        "Original server side exception message is " + e.getMessage(), e);
            }
            Exception clientException = new Exception();
            StackTraceElement[] clientStackTrace = clientException.getStackTrace();
            StackTraceElement[] completeStackTrace = new StackTraceElement[serverStackTrace.length + clientStackTrace.length];
            System.arraycopy(serverStackTrace, 0, completeStackTrace, 0, serverStackTrace.length);
            System.arraycopy(clientStackTrace, 0, completeStackTraceserverStackTrace.lengthclientStackTrace.length);
            Throwable responseException = null;
            if (e instanceof ServerInvoker.InvalidStateException && )
            {
               responseException = new CannotConnectException(e.getMessage(), e.getCause());
            }
            else
            {
               responseException = e;
            }
            
            if (e.getCause() != null)
            {
               responseException.getCause().setStackTrace(completeStackTrace);
            }
            else
            {
               responseException.setStackTrace(completeStackTrace);
            }
            throw responseException;
         }
         if () { .trace(this + " received InvocationResponse so going to return response's return value of " + returnValue);}
      }
      return returnValue;
   }

   
this method is called prior to making the remote invocation to allow the subclass the ability to provide additional data or modify the invocation

Parameters:
sessionId
param
sendPayload
receivedPayload
   protected void preProcess(String sessionIdObject paramMap sendPayloadMap receivedPayload)
   {
   }

   
this method is called prior to returning the result for the invocation to allow the subclass the ability to modify the result result

Parameters:
sessionId
param
sendPayload
receivedPayload
   protected void postProcess(String sessionIdObject paramMap sendPayload,
                              Map receivedPayload)
   {
   }
   protected abstract Object transport(String sessionIdObject invocationMap metadata,
                                       Marshaller marshallerUnMarshaller unmarshaller)
Subclasses must provide this method to return true if their remote connection is connected and false if disconnected. in some transports, such as SOAP, this method may always return true, since the remote connectivity is done on demand and not kept persistent like other transports (such as socket-based transport).

Returns:
boolean true if connected, false if not
   public boolean isConnected()
   {
      return ;
   }

   
Connect to the remote invoker.
   public synchronized void connect() throws ConnectionFailedException
   {
      if (!)
      {
         .debug(this + " connecting");
         handleConnect();
          = true;
         .debug(this + " connected");
      }
   }

   
Subclasses must implement this method to provide a hook to connect to the remote server, if this applies to the specific transport. However, in some transport implementations, this may not make must difference since the connection is not persistent among invocations, such as SOAP. In these cases, the method should silently return without any processing.

Throws:
ConnectionFailedException
   protected abstract void handleConnect() throws ConnectionFailedException;

   
Subclasses must implement this method to provide a hook to disconnect from the remote server, if this applies to the specific transport. However, in some transport implementations, this may not make must difference since the connection is not persistent among invocations, such as SOAP. In these cases, the method should silently return without any processing.
   protected abstract void handleDisconnect();

   
disconnect from the remote invokere
   public synchronized void disconnect()
   {
      if () { .trace(this + " disconnecting ..."); }
      if ()
      {
          = false;
         handleDisconnect();
         ClassLoader classLoader = getClassLoader();
         if (classLoader != null && classLoader instanceof ClassByteClassLoader)
         {
            ((ClassByteClassLoader).destroy();
         }
         if () { .trace(this + " disconnected"); }
      }
      else
      {
         if () { .trace(this + " is not connected!"); }
      }
   }
   public void setMarshaller(Marshaller marshaller)
   {
      this. = marshaller;
   }
   public Marshaller getMarshaller()
   {
      return this.;
   }
   public void setUnMarshaller(UnMarshaller unmarshaller)
   {
      this. = unmarshaller;
   }
   {
      return this.;
   }
   
   public String getSessionId()
   {
      return this.;
   }
   {
      return ;
   }
   public void setLeaseCreationTimeout(String leaseCreationTimeout)
   {
      this. = leaseCreationTimeout;
   }
   public void terminateLease(String sessionIdint disconnectTimeout)
   {
      terminateLease(sessionIddisconnectTimeoutnull);
   }
   
   public void terminateLease(String sessionIdint disconnectTimeoutLeasePinger passedLeasePinger)
   {
      synchronized()
      {
         if (passedLeasePinger != null && passedLeasePinger != )
         {
            if (.trace(this + ": " + passedLeasePinger + " != " + );
            return;
         }
         if (.trace(this + " entering terminateLease() for " + );
         if( != null)
         {
            if (disconnectTimeout == .)
            {
            	disconnectTimeout = Integer.parseInt();
            }
            .setDisconnectTimeout(disconnectTimeout);
            
            if (sessionId == null)
            {
               if (.trace(this + " shutting down LeasePinger: " + );
               // Independent of any particular Client - force LeasePinger shutdown.
               // Should be called only if there is a reasonable belief that the lease
               // has already stopped on the server side.
               try
               {
                  .stopPing();
               }
               catch (Exception e)
               {
                  .debug("error shutting down lease pinger" + e.getMessage());
                  .trace("error shutting down lease pinger"e);
               }
                = null;
            }
            else
            {
               // Remove a particular Client.
               if (.trace(this + " removing client " + sessionId + " from LeasePinger: " + );
               boolean isLastClientLease = .removeClient(sessionId);
               if(isLastClientLease)
               {
                  if (.trace(this + " shutting down LeasePinger, " + sessionId + " was last client lease: " + );
                  try
                  {
                     .stopPing();
                  }
                  catch (Exception e)
                  {
                     .debug("error shutting down lease pinger");
                  }
                   = null;
               }
            }
         }
         else
         {
            if (.trace(this + " leasePinger is null: must have been shut down already");
         }
         if (.trace(this + " leaving terminateLease() for " + );
      }
   }
   public long getLeasePeriod(String sessionID)
   {
      synchronized()
      {
         if( == null)
         {
            return -1;
         }
         return .getLeasePeriod(sessionID);
      }
   }
   public void establishLease(String clientSessionIDMap configurationlong leasePeriod)
      throws Throwable
   {
      Client client = (Clientconfiguration.get(.);
      ConnectionListener listener = (ConnectionListenerconfiguration.remove(.);
      boolean useClientConnectionIdentity = false;
      if (configuration != null)
      {
         Object o = configuration.get(.);
         if (o instanceof String)
         {
            useClientConnectionIdentity = Boolean.valueOf((Stringo).booleanValue();
         }
         else if (o != null)
         {
            .warn("value of " + . + " must be a String: " + o); 
         }
      }
      synchronized ()
      {
         // if already have a lease pinger, then already have a client with an established
         // lease and just need to update the lease pinger
         if ( != null)
         {
            try
            {
               .addClient(clientSessionIDconfigurationleasePeriod);
            }
            catch (RuntimeException e)
            {
               throw e.getCause();
            }
            if (.trace(this + " added client with session ID " + clientSessionID + " to " + );
         }
         else
         {
            try
            {
               if() { .trace(this + " sending initial lease ping to server to determine if server has leasing enabled."); }
               // configuration should NOT be passed as want ping to be specific to client invoker
               // and NOT to the client.
               String leasePingerId = new GUID().toString();
               Map requestMap = new HashMap();
               requestMap.put(.leasePingerId);
               requestMap.put(., Long.toString(System.currentTimeMillis()));
               requestMap.put(.);
               if (.trace(this + " initiating lease for leasePingerId " + leasePingerId);
               InvocationRequest ir = new InvocationRequest(null"$PING$"requestMapnew HashMap(), null);
               Object ret = invoke(ir);
               if (ret instanceof InvocationResponse)
               {
                  InvocationResponse resp = (InvocationResponseret;
                  Boolean shouldLease = (Boolean)resp.getResult();
                  if (shouldLease.booleanValue())
                  {
                     long defaultLeasePeriod = .;
                     Map respMap = resp.getPayload();
                     if (respMap != null)
                     {
                        Long leaseTimeoutValue = (Long)respMap.get("clientLeasePeriod");
                        long serverDefaultLeasePeriod = leaseTimeoutValue.longValue();
                        if(serverDefaultLeasePeriod > 0)
                        {
                           defaultLeasePeriod = serverDefaultLeasePeriod;
                        }
                     }
                     if() { .trace("server does have leasing enabled (with default lease period of " + defaultLeasePeriod + ") and will start a new lease pinger."); }
                      = new LeasePinger(thisdefaultLeasePeriod);
                     .setLeasePingerId(leasePingerId);
                     .setUseClientConnectionIdentity(useClientConnectionIdentity);
                     .addClient(clientSessionIDconfigurationleasePeriod);
                     .startPing();
                  }
               }
            }
            catch (Throwable throwable)
            {
               Exception e = new Exception("Error setting up client lease");
               e.initCause(throwable);
               throw e;
            }
         }
         if (.trace(this + ": client = " + client + ", listener = " + listener);
         if (client != null && listener != null)
         {
            client.addConnectionListener(listenerconfiguration);
         }
      }
   }

   
Will get the data type for the marshaller factory so know which marshaller to get to marshal the data. Will first check the locator uri for a 'datatype' parameter and take that value if it exists. Otherwise, will use the default datatype for the client invoker, based on transport.
   private String getDataType()
   {
      if ( == null)
      {
         String localDataType = getDataType(getLocator());
         if (localDataType == null)
         {
            localDataType = getDefaultDataType();
         }
          = localDataType;
      }
      return ;
   }
   private String getDataType(InvokerLocator locator)
   {
      String type = null;
      if (locator != null)
      {
         Map params = locator.getParameters();
         if (params != null)
         {
            type = (Stringparams.get(.);
            if (type == null)
            {
               type = (Stringparams.get(.);
            }
         }
      }
      return type;
   }
   
   protected void init()
   {
      // Get the parent delegation order flag, default is parent first
      if(flag == null)
      {
         // Fallback to the system property
      }
      boolean parentFirst = true;
      if (flag != null)
      {
         String sflag = flag.toString();
         parentFirst = Boolean.valueOf(sflag).booleanValue();
      }
       = parentFirst;
      
      if (flag != null)
      {
         String sflag = flag.toString();
          = Boolean.valueOf(sflag).booleanValue();
      }
      
      if (flag != null)
      {
         String sflag = flag.toString();
           = Boolean.valueOf(sflag).booleanValue();
      }
   }

   
Each implementation of the remote client invoker should have a default data type that is uses in the case it is not specified in the invoker locator uri.
   protected abstract String getDefaultDataType();


   
Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the finalize method to dispose of system resources or to perform other cleanup.

The general contract of finalize is that it is invoked if and when the JavaTM virtual machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, except as a result of an action taken by the finalization of some other object or class which is ready to be finalized. The finalize method may take any action, including making this object available again to other threads; the usual purpose of finalize, however, is to perform cleanup actions before the object is irrevocably discarded. For example, the finalize method for an object that represents an input/output connection might perform explicit I/O transactions to break the connection before the object is permanently discarded.

The finalize method of class Object performs no special action; it simply returns normally. Subclasses of Object may override this definition.

The Java programming language does not guarantee which thread will transport the finalize method for any given object. It is guaranteed, however, that the thread that invokes finalize will not be holding any user-visible synchronization locks when finalize is invoked. If an uncaught exception is thrown by the finalize method, the exception is ignored and finalization of that object terminates.

After the finalize method has been invoked for an object, no further action is taken until the Java virtual machine has again determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, including possible actions by other objects or classes which are ready to be finalized, at which point the object may be discarded.

The finalize method is never invoked more than once by a Java virtual machine for any given object.

Any exception thrown by the finalize method causes the finalization of this object to be halted, but is otherwise ignored.

Throws:
Throwable the Exception raised by this method
   protected void finalize() throws Throwable
   {
      disconnect();
      super.finalize();
   }
   protected LeasePinger getLeasePinger()
   {
      return ;
   }
New to GrepCode? Check out our FAQ X