org.jboss.mx.interceptor.ReflectedDispatcher Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jboss-as-mbeans
JBoss Application Server (mbeans module)
There is a newer version: 6.0.0.M1
/*
* 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.mx.interceptor;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import javax.management.Descriptor;
import javax.management.MBeanException;
import javax.management.ReflectionException;
import javax.management.RuntimeErrorException;
import javax.management.RuntimeMBeanException;
import javax.management.RuntimeOperationsException;
import javax.management.modelmbean.InvalidTargetObjectTypeException;

import org.jboss.mx.modelmbean.ModelMBeanConstants;
import org.jboss.mx.server.Invocation;

/**
 *
 * @author  Juha Lindfors.
 * @author [email protected]
 * @version $Revision: 37459 $
 *   
 */
public class ReflectedDispatcher extends AbstractInterceptor
{
   
   // Static --------------------------------------------------------
  
   // Attributes ----------------------------------------------------
   
   protected Method method = null;
   
   protected boolean dynamic;
   
   // Constructors --------------------------------------------------
   
   public ReflectedDispatcher()
   {
      super("Reflected Dispatcher");
   }
   
   public ReflectedDispatcher(boolean dynamic)
   {
      this();
      this.dynamic = dynamic;
   }
   
   public ReflectedDispatcher(Method m, boolean dynamic)
   {
      this(dynamic);
      this.method = m;
   }
  
   // Dispatcher implementation -------------------------------------
   
   public Object invoke(Invocation invocation) throws Throwable
   {
      Method invokeMethod = method;
      Object target = invocation.getTarget();
      String operationName = invocation.getName(); 
      if (dynamic)
      {
         // See whether we have a fqn
         String opName = operationName;
         String opClass = null; 
         int dot = opName.lastIndexOf('.');
         if (dot != -1)
         {
            opClass = operationName.substring(0, dot);
            opName = operationName.substring(dot+1);
         }
         
         // Does the descriptor have a target?
         Descriptor descriptor = invocation.getDescriptor();
         if (descriptor != null)
         {
            Object descriptorTarget = descriptor.getFieldValue(ModelMBeanConstants.TARGET_OBJECT);
            if (descriptorTarget != null)
            {
               String targetType = (String) descriptor.getFieldValue(ModelMBeanConstants.TARGET_TYPE);
               if (ModelMBeanConstants.OBJECT_REF.equalsIgnoreCase(targetType) == false)
                  throw new InvalidTargetObjectTypeException("Target type is " + targetType);
               target = descriptorTarget;

               // Determine the method
               Class clazz = null;
               String className = (String) descriptor.getFieldValue(ModelMBeanConstants.CLASS);
               if (className == null)
                  className = opClass;
               if (className == null)
                  clazz = target.getClass();
               else
               {
                  try
                  {
                     if (clazz == null)
                        clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
                  }
                  catch (Exception e)
                  {
                     throw new ReflectionException(e, "Error loading class for operation " + opName);
                  }
               }
               Class[] sig;
               try
               {
                  sig = invocation.getSignatureClasses();
               }
               catch (Exception e)
               {
                  throw new ReflectionException(e, "Error loading signature classes for operation " + opName);
               }
               try
               {
                  invokeMethod = clazz.getDeclaredMethod(opName, sig);
               }
               catch (Exception e)
               {
                  throw new ReflectionException(e, "Error getting method for operation " + opName);
               }
            }
         }
      }
      
      if (target == null)
      {
         String msg = "Failed to find method for operation: " + invocation
            + " on resource: " + invocation.getInvoker().getResource()
            + " objectName: " + invocation.getInvoker().getObjectName();
         throw new ReflectionException(new NullPointerException(msg));
      }

      try
      {
         Object[] args = invocation.getArgs();
         return invokeMethod.invoke(target, args);
      }
      catch (NullPointerException e)
      {
         throw new NullPointerException("Error in operation=" + operationName + " method=" + method + " target=" + target);
      }
      catch (Throwable t)
      {
         handleInvocationExceptions(t);
         return null;
      }
   }

   // Protected -----------------------------------------------------
   protected void handleInvocationExceptions(Throwable t) throws Throwable
   {      
      // the invoked method threw an exception
      if (t instanceof InvocationTargetException)
      {
         t = ((InvocationTargetException) t).getTargetException();
         if (t instanceof RuntimeOperationsException)
            throw (RuntimeOperationsException) t;
         else if (t instanceof RuntimeException)
            throw new RuntimeMBeanException((RuntimeException) t);
         else if (t instanceof Error)
            throw new RuntimeErrorException((Error) t);
         else if (t instanceof Exception)
            throw new MBeanException((Exception) t);
         else
            throw t;
      }
      else if (t instanceof Exception)
         throw new ReflectionException((Exception) t);
      else if (t instanceof Error)
         throw new RuntimeErrorException((Error) t);
      else
         throw t;
   }
      
}