public InvokerInterceptor() 
{
      super();
}

Exposed for externalization.

 public static Invoker getLocal() 
{
   
      try
      {
         // Using Class.forName() to avoid security problems in the client
         invokerProxyHA = Class.forName("org.jboss.invocation.InvokerProxyHA");
      }
      catch (Throwable ignored)
      {
      }
      return localInvoker;
}

Get the local invoker reference, useful for optimization.

 public boolean hasLocalTarget(Invocation invocation) 
{
      return Registry.lookup(invocation.getObjectName()) != null;
}

Whether there is a local target

 public Object invoke(Invocation invocation) throws Exception 
{
      // optimize if calling another bean in same server VM
      if (isLocal(invocation))
         return invokeLocal(invocation);
      else
         return invokeInvoker(invocation);
}

The invocation on the delegate, calls the right invoker. Remote if we are remote, local if we are local.

 protected Object invokeInvoker(Invocation invocation) throws Exception 
{
      //Specify that it is inter-vm on the invocation
      invocation.setInterVM(Boolean.TRUE);
      InvocationContext ctx = invocation.getInvocationContext();
      Invoker invoker = ctx.getInvoker();
      return invoker.invoke(invocation);
}

Invoke using invoker

 protected Object invokeLocal(Invocation invocation) throws Exception 
{
      return localInvoker.invoke(invocation);
}

Invoke using local invoker

 protected Object invokeMarshalled(Invocation invocation) throws Exception 
{
      MarshalledInvocation mi = new MarshalledInvocation(invocation);
      MarshalledValue copy = new MarshalledValue(mi);
      Invocation invocationCopy = (Invocation) copy.get();
      // copy the Tx
      Transaction tx = invocation.getTransaction();
      invocationCopy.setTransaction(tx);
      try
      {
         Object rtnValue = localInvoker.invoke(invocationCopy);
         MarshalledValue mv = new MarshalledValue(rtnValue);
         return mv.get();
      }
      catch(Throwable t)
      {
         MarshalledValue mv = new MarshalledValue(t);
         Throwable t2 = (Throwable) mv.get();
         if( t2 instanceof Exception )
            throw (Exception) t2;
         else
            throw new UndeclaredThrowableException(t2);
      }
}

Invoke using local invoker and marshalled

 public boolean isClustered(Invocation invocation) 
{
      // No clustering classes
      if (invokerProxyHA == null)
         return false;
      // Is the invoker a HA invoker?
      InvocationContext ctx = invocation.getInvocationContext();
      Invoker invoker = ctx.getInvoker();
      return invoker != null && invokerProxyHA.isAssignableFrom(invoker.getClass());
}

Whether we are in a clustered environment

NOTE: This should be future compatible under any new design where a prior target chooser interceptor picks a non HA target than that code being inside a ha invoker.

 public boolean isLocal() 
{
      return invokerID.equals(Invoker.ID);
}

Returns wether we are local to the originating container or not.

 public boolean isLocal(Invocation invocation) 
{
      // No local invoker, it must be remote
      if (localInvoker == null)
         return false;
      // The proxy was downloaded from a remote location
      if (isLocal() == false)
      {
         // It is not clustered so we go remote
         if (isClustered(invocation) == false)
            return false;
      }
      // See whether we have a local target
      return hasLocalTarget(invocation);
}

Whether the target is local

 public  void readExternal(ObjectInput in) throws ClassNotFoundException, IOException 
{
      invokerID = (GUID)in.readObject();
}

Un-externalize this instance.

We check timestamps of the interfaces to see if the instance is in the original VM of creation

 public static  void setLocal(Invoker invoker) 
{
      localInvoker = invoker;
}

Set the local invoker reference, useful for optimization.

 public  void writeExternal(ObjectOutput out) throws IOException 
{
      out.writeObject(invokerID);
}

Externalize this instance.

If this instance lives in a different VM than its container invoker, the remote interface of the container invoker is not externalized.