Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
  * JBoss, Home of Professional Open Source
  * Copyright 2005, JBoss Inc., and individual contributors as indicated
  * by the @authors tag. See the copyright.txt in the distribution for a
  * full listing of individual contributors.
  *
  * This is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
 
 package org.jboss.remoting;
 
 import  org.jboss.logging.Logger;
 import  org.jboss.util.id.GUID;
 
 import java.util.Map;
 import java.util.List;
 import java.util.Set;

AbstractInvoker is an abstract handler part that contains common methods between both client and server.

Author(s):
Jeff Haynie
Tom Elrod
Version:
$Revision: 5270 $
 
 public abstract class AbstractInvoker implements Invoker
 {
    protected final static Logger log = Logger.getLogger(AbstractInvoker.class);
    protected InvokerLocator locator;
    protected Map localServerLocators = new HashMap();
    protected String serializationType;
    protected Map configuration = new HashMap();
    protected SocketFactory socketFactory;
    protected boolean passConfigMapToMarshalFactory;
 
    // Indicates if the serverSocketFactory was generated internally.
    protected boolean socketFactoryCreatedFromSSLParameters;
 
    public AbstractInvoker(InvokerLocator locator)
    {
       this(locatornull);
    }
 
    public AbstractInvoker(InvokerLocator locatorMap configuration)
    {
 	  try
 	  {
 	      this. = (ClassByteClassLoader)AccessController.doPrivilegednew PrivilegedExceptionAction()
 	      {
 	         public Object run() throws Exception
 	         {
 	        	 return new ClassByteClassLoader(this.getClass().getClassLoader());
 	         }
 	      });
 	  }
 	  catch (PrivilegedActionException e)
 	  {
 		  .error(e.toString(), e);
 		  throw new RuntimeException("Can't create a ClassLoader"e);
 	  }
       this. = locator;
 
       if (configuration != null)
          this..putAll(configuration);
 
      if (locator.getParameters() != null)
         this..putAll(locator.getParameters());
      try
      {
         InvokerLocator loaderLocator = MarshallLoaderFactory.convertLocator(locator);
         if(loaderLocator != null)
         {
            .setClientInvoker(new Client(loaderLocator));
         }
      }
      catch(Exception e)
      {
         .error("Could not create remote class loading for invoker."e);
      }
      if(locator == null || locator.getParameters() == null)
      {
      }
      else
      {
         this.setSerializationType(locator.findSerializationType());
      }
      if (o instanceof String)
      {
         this. = Boolean.valueOf((Stringo).booleanValue();
      }
      else if (o != null)
      {
         .warn("value of " + . + " must be a String: " + o); 
      }
   }

   
return the locator this Invoker represents
   public InvokerLocator getLocator()
   {
      return ;
   }

   
Generates a listener id for the callbackhandler and callback server locator combination

Parameters:
sessionId
locator
   public String addClientLocator(String sessionIdInvokerCallbackHandler callbackhandlerInvokerLocator locator)
   {
      String listenerId = null;
      synchronized()
      {
         Collection holders = .values();
         Iterator itr = holders.iterator();
         while(itr.hasNext())
         {
            CallbackHandlerHolder holder = (CallbackHandlerHolder)itr.next();
            InvokerCallbackHandler holderhandler = holder.getHandler();
            boolean handlersEqual = holderhandler.equals(callbackhandler);
            InvokerLocator handlerLocator = holder.getLocator();
            boolean locatorsEqual = handlerLocator.equals(locator);
            if(handlersEqual && locatorsEqual)
            {
               // the entry already exists for this pair, so return null
               return null;
            }
         }
         // if got this far, the entry does not exist, so need to add it and create a listener id
         CallbackHandlerHolder holder = new CallbackHandlerHolder(callbackhandlerlocator);
         listenerId = new GUID().toString();
         String key = listenerId;
         if (sessionId != null)
            key = sessionId + "+" + listenerId;
         .put(keyholder);
      }
      return listenerId;
   }

   
Gets the client locator. This locator will be used by the server side to make callbacks to the handler for this locator.
   public InvokerLocator getClientLocator(String listenerId)
   {
      InvokerLocator locator = null;
      if(listenerId != null)
      {
         CallbackHandlerHolder holder = (CallbackHandlerHolder.get(listenerId);
         if(holder != null)
         {
            locator = holder.getLocator();
         }
      }
      return locator;
   }
   public List getClientLocators(String sessionIdInvokerCallbackHandler handler)
   {
      List holderList = new ArrayList();
      if(handler != null)
      {
         synchronized()
         {
            Set entries = .entrySet();
            Iterator itr = entries.iterator();
            while(itr.hasNext())
            {
               Map.Entry entry = (Map.Entryitr.next();
               String listenerId = (Stringentry.getKey();
               int index = listenerId.indexOf('+');
               String prefix = listenerId.substring(0, index);
               if (!sessionId.equals(prefix))
                  continue;
               if (index >= 0)
                  listenerId = listenerId.substring(index + 1);
               CallbackHandlerHolder holder = (CallbackHandlerHolderentry.getValue();
               InvokerCallbackHandler holderHandler = holder.getHandler();
               if(holderHandler.equals(handler))
               {
                  CallbackLocatorHolder locatorHolder = new CallbackLocatorHolder(listenerIdholder.getLocator());
                  holderList.add(locatorHolder);
               }
            }
            // now remove holders
            if(holderList.size() > 0)
            {
               for(int x = 0; x < holderList.size(); x++)
               {
                  String listenerId = ((CallbackLocatorHolder)holderList.get(x)).getListenerId();
                  String key = sessionId + "+" + listenerId;
                  .remove(key);
               }
            }
         }
      }
         return holderList;
   }

   
set the classloader to use internally

Parameters:
classloader
   public synchronized void setClassLoader(ClassLoader classloader)
   {
	  try
	  {
	      this. = (ClassByteClassLoader)AccessController.doPrivilegednew PrivilegedExceptionAction()
	      {
	         public Object run() throws Exception
	         {
	        	 return new ClassByteClassLoader(this.getClass().getClassLoader());
	         }
	      });
	  }
	  {
		  .error(e.toString(), e);
		  throw new RuntimeException("Can't create a ClassLoader"e);
	  }
   }
   public synchronized ClassLoader getClassLoader()
   {
      return ;
   }
   {
      return ;
   }
   public void setSerializationType(String serializationType)
   {
      this. = serializationType;
   }
   {
      return ;
   }
   public void setSocketFactory(SocketFactory socketFactory)
   {
      this. = socketFactory;
   }
   {
   }

   
If any configuration parameters relate to the construction of a SSLSocketBuilder, create one.
   protected SocketFactory createSocketFactory(Map configuration)
   {
      if (configuration == null)
         return null;
      if ( != null)
         return ;
      SocketFactory factory = null;
      Object obj = configuration.get(.);
      if (obj != null)
      {
         if (obj instanceof SocketFactory)
         {
            factory = (SocketFactoryobj;
         }
         else
         {
            throw new RuntimeException("Can not set custom socket factory (" + obj + ") as is not of type javax.net.SocketFactory");
         }
      }
      if(factory == null)
      {
         String socketFactoryString = (String)configuration.get(.);
         if (socketFactoryString == null)
         {
            socketFactoryString = (String)configuration.get(.);            
         }
         
         if(socketFactoryString != null && socketFactoryString.length() > 0)
         {
            try
            {
               Class cl = ClassLoaderUtility.loadClass(socketFactoryString,  getClass());
               Constructor socketFactoryConstructor = null;
               socketFactoryConstructor = cl.getConstructor(new Class[]{});
               factory = (SocketFactory)socketFactoryConstructor.newInstance(new Object[] {});
               .trace("SocketFactory (" + socketFactoryString + ") loaded");
            }
            catch(Exception e)
            {
               .debug("Could not create socket factory by classname (" + socketFactoryString + ").  Error message: " + e.getMessage());
            }
         }
      }
      if (factory == null && needsCustomSSLConfiguration(configuration))
      {
         try
         {
            SSLSocketBuilder socketBuilder = new SSLSocketBuilder(configuration);
            socketBuilder.setUseSSLSocketFactoryfalse );
            factory = socketBuilder.createSSLSocketFactory();
             = true;
         }
         catch (IOException e)
         {
            throw new RuntimeException("Unable to create customized SSL socket factory"e);
         }
      }
      return wrapSocketFactory(factoryconfiguration);
   }
   
   protected Map getConfiguration()
   {
      return ;
   }
   
   static public SocketFactory wrapSocketFactory(SocketFactory socketFactoryMap config)
   {
      if (config == null)
         return socketFactory;
      
      
      if (o == null)
         return socketFactory;
      
      if (o instanceof SocketCreationListener)
      {
         SocketCreationListener listener = (SocketCreationListenero;
         return new CreationListenerSocketFactory(socketFactorylistener);
      }
      else if (o instanceof String)
      {
         try
         {
            Class c = ClassLoaderUtility.loadClass((StringoAbstractInvoker.class);
            SocketCreationListener listener = (SocketCreationListenerc.newInstance();
            return new CreationListenerSocketFactory(socketFactorylistener);
         }
         catch (Exception e)
         {
            .error("unable to instantiate class: " + oe);
            return socketFactory;
         }
      }
      else
      {
         .error("unrecognized type for socket creation client listener: " + o);
         return socketFactory;
      }
   }
   
   
   static public boolean isCompleteSocketFactory(SocketFactory sf)
   {
      if (sf != null)
      {
         if (!(sf instanceof SocketFactoryWrapper) ||
             ((SocketFactoryWrapper)sf).getSocketFactory() != null)
            return true;
      }
      return false;
   }
   public static boolean needsCustomSSLConfiguration(Map configuration)
   {
      if (configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null ||
            configuration.get(.) != null
      )
         return true;
      else
         return false;
   }
   private class CallbackHandlerHolder
   {
      private InvokerCallbackHandler handler;
      private InvokerLocator locator;
      private CallbackHandlerHolder(InvokerCallbackHandler handlerInvokerLocator locator)
      {
         this. = handler;
         this. = locator;
      }
      public InvokerCallbackHandler getHandler()
      {
         return ;
      }
      public InvokerLocator getLocator()
      {
         return ;
      }
   }
   public class CallbackLocatorHolder
   {
      private InvokerLocator locator;
      private String listenerId;
      public CallbackLocatorHolder(String listenerIdInvokerLocator locator)
      {
         this. = listenerId;
         this. = locator;
      }
      public String getListenerId()
      {
         return ;
      }
      public InvokerLocator getLocator()
      {
         return ;
      }
   }
New to GrepCode? Check out our FAQ X