geode-core/src/main/java/org/apache/geode/management/internal/MBeanProxyInvocationHandler.java - geode - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
  * agreements. See the NOTICE file distributed with this work for additional information regarding
  * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance with the License. You may obtain a
  * copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 package org.apache.geode.management.internal;

 import java.io.InvalidObjectException;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Arrays;
 import java.util.List;

 import javax.management.JMX;
 import javax.management.ListenerNotFoundException;
 import javax.management.MBeanException;
 import javax.management.MBeanInfo;
 import javax.management.MBeanNotificationInfo;
 import javax.management.Notification;
 import javax.management.NotificationBroadcaster;
 import javax.management.NotificationBroadcasterSupport;
 import javax.management.NotificationEmitter;
 import javax.management.NotificationFilter;
 import javax.management.NotificationListener;
 import javax.management.ObjectName;
 import javax.management.openmbean.OpenDataException;

 import org.apache.logging.log4j.Logger;

 import org.apache.geode.SystemFailure;
 import org.apache.geode.annotations.VisibleForTesting;
 import org.apache.geode.cache.Region;
 import org.apache.geode.cache.execute.FunctionService;
 import org.apache.geode.cache.execute.ResultCollector;
 import org.apache.geode.distributed.DistributedMember;
 import org.apache.geode.logging.internal.log4j.api.LogService;

 /**
  * This class is the proxy handler for all the proxies created for federated MBeans. Its designed
  * with Java proxy mechanism. All data calls are delegated to the federation components. All method
  * calls are routed to specified members via Function service
  */
 public class MBeanProxyInvocationHandler implements InvocationHandler {
   private static final Logger logger = LogService.getLogger();

   private final ObjectName objectName;
   private final Region<String, Object> monitoringRegion;
   private final DistributedMember member;
   private final NotificationBroadcasterSupport emitter;
   private final ProxyInterface proxyImpl;
   private final boolean isMXBean;

   private MXBeanProxyInvocationHandler mxBeanProxyInvocationHandler;

   static Object newProxyInstance(DistributedMember member, Region<String, Object> monitoringRegion,
       ObjectName objectName, FederationComponent federationComponent, Class interfaceClass) {
     boolean isMXBean = JMX.isMXBeanInterface(interfaceClass);
     boolean notificationBroadcaster = federationComponent.isNotificationEmitter();

     InvocationHandler invocationHandler =
         new MBeanProxyInvocationHandler(member, objectName, monitoringRegion, isMXBean);

     Class[] interfaces;
     if (notificationBroadcaster) {
       interfaces =
           new Class[] {interfaceClass, ProxyInterface.class, NotificationBroadCasterProxy.class};
     } else {
       interfaces = new Class[] {interfaceClass, ProxyInterface.class};
     }

     Object proxy = Proxy.newProxyInstance(MBeanProxyInvocationHandler.class.getClassLoader(),
         interfaces, invocationHandler);

     return interfaceClass.cast(proxy);
   }

   private MBeanProxyInvocationHandler(DistributedMember member, ObjectName objectName,
       Region<String, Object> monitoringRegion, boolean isMXBean) {
     this(member, objectName, monitoringRegion, isMXBean, new NotificationBroadcasterSupport(),
         new ProxyInterfaceImpl());
   }

   @VisibleForTesting
   MBeanProxyInvocationHandler(DistributedMember member, ObjectName objectName,
       Region<String, Object> monitoringRegion, boolean isMXBean,
       NotificationBroadcasterSupport emitter, ProxyInterface proxyImpl) {
     this.member = member;
     this.objectName = objectName;
     this.monitoringRegion = monitoringRegion;
     this.isMXBean = isMXBean;
     this.emitter = emitter;
     this.proxyImpl = proxyImpl;
   }

   /**
    * Inherited method from Invocation handler All object state requests are delegated to the
    * federated component.
    *
    * <p>
    * All setters and operations() are delegated to the function service.
    *
    * <p>
    * Notification emitter methods are also delegated to the function service
    */
   @Override
   public Object invoke(Object proxy, Method method, Object[] arguments)
       throws MBeanException, ListenerNotFoundException, InvalidObjectException, OpenDataException {
     if (logger.isTraceEnabled()) {
       logger.trace("Invoking Method {}", method.getName());
     }

     Class methodClass = method.getDeclaringClass();
     if (methodClass.equals(NotificationBroadcaster.class)
         || methodClass.equals(NotificationEmitter.class)) {
       return invokeBroadcasterMethod(method, arguments);
     }

     String methodName = method.getName();
     Class[] parameterTypes = method.getParameterTypes();
     Class returnType = method.getReturnType();

     int argumentCount = arguments == null ? 0 : arguments.length;

     if (methodName.equals("setLastRefreshedTime")) {
       proxyImpl.setLastRefreshedTime((Long) arguments[0]);
       return null;
     }
     if (methodName.equals("getLastRefreshedTime")) {
       return proxyImpl.getLastRefreshedTime();
     }
     if (methodName.equals("sendNotification")) {
       sendNotification(arguments[0]);
       return null;
     }

     // local or not: equals, toString, hashCode
     if (shouldDoLocally(method)) {
       return doLocally(method, arguments);
     }

     // Support For MXBean open types
     if (isMXBean) {
       MXBeanProxyInvocationHandler p = findMXBeanProxy(objectName, methodClass, this);
       return p.invoke(proxy, method, arguments);
     }

     if (methodName.startsWith("get") && methodName.length() > 3 && argumentCount == 0
         && !returnType.equals(Void.TYPE)) {
       return delegateToObjectState(methodName.substring(3));
     }

     if (methodName.startsWith("is") && methodName.length() > 2 && argumentCount == 0
         && (returnType.equals(Boolean.TYPE) || returnType.equals(Boolean.class))) {
       return delegateToObjectState(methodName.substring(2));
     }

     String[] signature = new String[parameterTypes.length];
     for (int i = 0; i < parameterTypes.length; i++) {
       signature[i] = parameterTypes[i].getName();
     }

     return delegateToFunctionService(objectName, methodName, arguments, signature);
   }

   /**
    * This will get the data from Object state which is replicated across the hidden region
    * FederationComponent being the carrier.
    */
   Object delegateToObjectState(String attributeName) throws MBeanException {
     try {
       FederationComponent federation =
           (FederationComponent) monitoringRegion.get(objectName.toString());
       return federation.getValue(attributeName);
     } catch (Exception e) {
       throw new MBeanException(e);
     } catch (VirtualMachineError e) {
       SystemFailure.initiateFailure(e);
       throw e;
     } catch (Throwable t) {
       SystemFailure.checkFailure();
       throw new MBeanException(new Exception(t.getLocalizedMessage()));
     }
   }

   /**
    * It will call the Generic function to execute the method on the remote VM
    */
   Object delegateToFunctionService(ObjectName objectName, String methodName, Object[] arguments,
       String[] signature) throws MBeanException {
     Object[] functionArguments = new Object[5];
     functionArguments[0] = objectName;
     functionArguments[1] = methodName;
     functionArguments[2] = signature;
     functionArguments[3] = arguments;
     functionArguments[4] = member.getName();

     List<Object> result;
     try {
       ResultCollector resultCollector = FunctionService.onMember(member)
           .setArguments(functionArguments)
           .execute(ManagementConstants.MGMT_FUNCTION_ID);
       result = (List<Object>) resultCollector.getResult();
     } catch (Exception e) {
       if (logger.isDebugEnabled()) {
         logger.debug(" Exception while Executing Function {}", e.getMessage(), e);
       }
       // Only in case of Exception caused for Function framework.
       return null;
     } catch (VirtualMachineError e) {
       SystemFailure.initiateFailure(e);
       throw e;
     } catch (Throwable t) {
       SystemFailure.checkFailure();
       if (logger.isDebugEnabled()) {
         logger.debug(" Error while Executing Function {}", t.getMessage(), t);
       }
       return null;
     }

     return checkErrors(result.get(ManagementConstants.RESULT_INDEX));
   }

   /**
    * As this proxy may behave as an notification emitter it delegates to the member
    * NotificationBroadcasterSupport object
    */
   private void sendNotification(Object notification) {
     emitter.sendNotification((Notification) notification);
   }

   private Object checkErrors(Object lastResult) throws MBeanException {
     if (lastResult instanceof MBeanException) {
       // Convert all MBean public API exceptions to MBeanException
       throw (MBeanException) lastResult;
     }
     if (lastResult instanceof Exception) {
       return null;
     }
     if (lastResult instanceof Throwable) {
       return null;
     }
     return lastResult;
   }

   /**
    * The call will delegate to Managed Node for NotificationHub to register a local listener to
    * listen for notification from the MBean
    *
    * <p>
    * Moreover it will also add the client to local listener list by adding to the contained emitter.
    */
   private Object invokeBroadcasterMethod(Method method, Object[] arguments)
       throws MBeanException, ListenerNotFoundException {
     String methodName = method.getName();
     int argumentCount = arguments == null ? 0 : arguments.length;

     Class[] parameterTypes = method.getParameterTypes();
     String[] signature = new String[parameterTypes.length];

     switch (methodName) {
       case "addNotificationListener": {
         // The various throws of IllegalArgumentException here should not happen, since we know what
         // the methods in NotificationBroadcaster and NotificationEmitter are.

         if (argumentCount != 3) {
           throw new IllegalArgumentException(
               "Bad arg count to addNotificationListener: " + argumentCount);
         }

         // Other inconsistencies will produce ClassCastException below.

         NotificationListener listener = (NotificationListener) arguments[0];
         NotificationFilter filter = (NotificationFilter) arguments[1];
         Object handback = arguments[2];
         emitter.addNotificationListener(listener, filter, handback);
         delegateToFunctionService(objectName, methodName, null, signature);
         return null;
       }

       case "removeNotificationListener": {
         // NullPointerException if method with no args, but that shouldn't happen because
         // removeNotificationListener does have args.
         NotificationListener listener = (NotificationListener) arguments[0];

         switch (argumentCount) {
           case 1:
             emitter.removeNotificationListener(listener);

             // No need to send listener and filter details to other members. We only need to send a
             // message saying remove the listener registered for this object on your side.

             delegateToFunctionService(objectName, methodName, null, signature);
             return null;

           case 3:
             NotificationFilter filter = (NotificationFilter) arguments[1];
             Object handback = arguments[2];
             emitter.removeNotificationListener(listener, filter, handback);

             delegateToFunctionService(objectName, methodName, null, signature);
             return null;

           default:
             throw new IllegalArgumentException(
                 "Bad arg count to removeNotificationListener: " + argumentCount);
         }
       }

       case "getNotificationInfo":
         if (arguments != null) {
           throw new IllegalArgumentException("getNotificationInfo has " + "args");
         }

         if (!MBeanJMXAdapter.mbeanServer.isRegistered(objectName)) {
           return new MBeanNotificationInfo[0];
         }

         // MBean info is delegated to function service as intention is to get the info of the actual
         // mbean rather than the proxy

         Object obj = delegateToFunctionService(objectName, methodName, arguments, signature);
         if (obj instanceof String) {
           return new MBeanNotificationInfo[0];
         }
         MBeanInfo info = (MBeanInfo) obj;
         return info.getNotifications();

       default:
         throw new IllegalArgumentException("Bad method name: " + methodName);
     }
   }

   private boolean shouldDoLocally(Method method) {
     String methodName = method.getName();
     if ((methodName.equals("hashCode") || methodName.equals("toString"))
         && method.getParameterTypes().length == 0) {
       return true;
     }
     return methodName.equals("equals")
         && Arrays.equals(method.getParameterTypes(), new Class[] {Object.class});
   }

   private Object doLocally(Method method, Object[] arguments) {
     String methodName = method.getName();
     FederationComponent federation =
         (FederationComponent) monitoringRegion.get(objectName.toString());

     switch (methodName) {
       case "equals":
         return federation.equals(arguments[0]);
       case "toString":
         return federation.toString();
       case "hashCode":
         return federation.hashCode();
     }

     throw new IllegalArgumentException("Unexpected method name: " + methodName);
   }

   private MXBeanProxyInvocationHandler findMXBeanProxy(ObjectName objectName,
       Class<?> mbeanInterface, MBeanProxyInvocationHandler handler) {
     if (mxBeanProxyInvocationHandler == null) {
       synchronized (this) {
         try {
           mxBeanProxyInvocationHandler =
               new MXBeanProxyInvocationHandler(objectName, mbeanInterface, handler);
         } catch (IllegalArgumentException e) {
           String message =
               "Cannot make MXBean proxy for " + mbeanInterface.getName() + ": " + e.getMessage();
           throw new IllegalArgumentException(message, e.getCause());
         }
       }
     }
     return mxBeanProxyInvocationHandler;
   }

   /**
    * Internal implementation of all the generic proxy methods
    */
   private static class ProxyInterfaceImpl implements ProxyInterface {

     private volatile long lastRefreshedTime;

     private ProxyInterfaceImpl() {
       lastRefreshedTime = System.currentTimeMillis();
     }

     @Override
     public long getLastRefreshedTime() {
       return lastRefreshedTime;
     }

     @Override
     public void setLastRefreshedTime(long lastRefreshedTime) {
       this.lastRefreshedTime = lastRefreshedTime;
     }
   }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more contributor license
	* agreements. See the NOTICE file distributed with this work for additional information regarding
	* copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance with the License. You may obtain a
	* copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software distributed under the License
	* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
	* or implied. See the License for the specific language governing permissions and limitations under
	* the License.
	*/
	package org.apache.geode.management.internal;

	import java.io.InvalidObjectException;
	import java.lang.reflect.InvocationHandler;
	import java.lang.reflect.Method;
	import java.lang.reflect.Proxy;
	import java.util.Arrays;
	import java.util.List;

	import javax.management.JMX;
	import javax.management.ListenerNotFoundException;
	import javax.management.MBeanException;
	import javax.management.MBeanInfo;
	import javax.management.MBeanNotificationInfo;
	import javax.management.Notification;
	import javax.management.NotificationBroadcaster;
	import javax.management.NotificationBroadcasterSupport;
	import javax.management.NotificationEmitter;
	import javax.management.NotificationFilter;
	import javax.management.NotificationListener;
	import javax.management.ObjectName;
	import javax.management.openmbean.OpenDataException;

	import org.apache.logging.log4j.Logger;

	import org.apache.geode.SystemFailure;
	import org.apache.geode.annotations.VisibleForTesting;
	import org.apache.geode.cache.Region;
	import org.apache.geode.cache.execute.FunctionService;
	import org.apache.geode.cache.execute.ResultCollector;
	import org.apache.geode.distributed.DistributedMember;
	import org.apache.geode.logging.internal.log4j.api.LogService;

	/**
	* This class is the proxy handler for all the proxies created for federated MBeans. Its designed
	* with Java proxy mechanism. All data calls are delegated to the federation components. All method
	* calls are routed to specified members via Function service
	*/
	public class MBeanProxyInvocationHandler implements InvocationHandler {
	private static final Logger logger = LogService.getLogger();

	private final ObjectName objectName;
	private final Region<String, Object> monitoringRegion;
	private final DistributedMember member;
	private final NotificationBroadcasterSupport emitter;
	private final ProxyInterface proxyImpl;
	private final boolean isMXBean;

	private MXBeanProxyInvocationHandler mxBeanProxyInvocationHandler;

	static Object newProxyInstance(DistributedMember member, Region<String, Object> monitoringRegion,
	ObjectName objectName, FederationComponent federationComponent, Class interfaceClass) {
	boolean isMXBean = JMX.isMXBeanInterface(interfaceClass);
	boolean notificationBroadcaster = federationComponent.isNotificationEmitter();

	InvocationHandler invocationHandler =
	new MBeanProxyInvocationHandler(member, objectName, monitoringRegion, isMXBean);

	Class[] interfaces;
	if (notificationBroadcaster) {
	interfaces =
	new Class[] {interfaceClass, ProxyInterface.class, NotificationBroadCasterProxy.class};
	} else {
	interfaces = new Class[] {interfaceClass, ProxyInterface.class};
	}

	Object proxy = Proxy.newProxyInstance(MBeanProxyInvocationHandler.class.getClassLoader(),
	interfaces, invocationHandler);

	return interfaceClass.cast(proxy);
	}

	private MBeanProxyInvocationHandler(DistributedMember member, ObjectName objectName,
	Region<String, Object> monitoringRegion, boolean isMXBean) {
	this(member, objectName, monitoringRegion, isMXBean, new NotificationBroadcasterSupport(),
	new ProxyInterfaceImpl());
	}

	@VisibleForTesting
	MBeanProxyInvocationHandler(DistributedMember member, ObjectName objectName,
	Region<String, Object> monitoringRegion, boolean isMXBean,
	NotificationBroadcasterSupport emitter, ProxyInterface proxyImpl) {
	this.member = member;
	this.objectName = objectName;
	this.monitoringRegion = monitoringRegion;
	this.isMXBean = isMXBean;
	this.emitter = emitter;
	this.proxyImpl = proxyImpl;
	}

	/**
	* Inherited method from Invocation handler All object state requests are delegated to the
	* federated component.
	*
	* <p>
	* All setters and operations() are delegated to the function service.
	*
	* <p>
	* Notification emitter methods are also delegated to the function service
	*/
	@Override
	public Object invoke(Object proxy, Method method, Object[] arguments)
	throws MBeanException, ListenerNotFoundException, InvalidObjectException, OpenDataException {
	if (logger.isTraceEnabled()) {
	logger.trace("Invoking Method {}", method.getName());
	}

	Class methodClass = method.getDeclaringClass();
	if (methodClass.equals(NotificationBroadcaster.class)
	\|\| methodClass.equals(NotificationEmitter.class)) {
	return invokeBroadcasterMethod(method, arguments);
	}

	String methodName = method.getName();
	Class[] parameterTypes = method.getParameterTypes();
	Class returnType = method.getReturnType();

	int argumentCount = arguments == null ? 0 : arguments.length;

	if (methodName.equals("setLastRefreshedTime")) {
	proxyImpl.setLastRefreshedTime((Long) arguments[0]);
	return null;
	}
	if (methodName.equals("getLastRefreshedTime")) {
	return proxyImpl.getLastRefreshedTime();
	}
	if (methodName.equals("sendNotification")) {
	sendNotification(arguments[0]);
	return null;
	}

	// local or not: equals, toString, hashCode
	if (shouldDoLocally(method)) {
	return doLocally(method, arguments);
	}

	// Support For MXBean open types
	if (isMXBean) {
	MXBeanProxyInvocationHandler p = findMXBeanProxy(objectName, methodClass, this);
	return p.invoke(proxy, method, arguments);
	}

	if (methodName.startsWith("get") && methodName.length() > 3 && argumentCount == 0
	&& !returnType.equals(Void.TYPE)) {
	return delegateToObjectState(methodName.substring(3));
	}

	if (methodName.startsWith("is") && methodName.length() > 2 && argumentCount == 0
	&& (returnType.equals(Boolean.TYPE) \|\| returnType.equals(Boolean.class))) {
	return delegateToObjectState(methodName.substring(2));
	}

	String[] signature = new String[parameterTypes.length];
	for (int i = 0; i < parameterTypes.length; i++) {
	signature[i] = parameterTypes[i].getName();
	}

	return delegateToFunctionService(objectName, methodName, arguments, signature);
	}

	/**
	* This will get the data from Object state which is replicated across the hidden region
	* FederationComponent being the carrier.
	*/
	Object delegateToObjectState(String attributeName) throws MBeanException {
	try {
	FederationComponent federation =
	(FederationComponent) monitoringRegion.get(objectName.toString());
	return federation.getValue(attributeName);
	} catch (Exception e) {
	throw new MBeanException(e);
	} catch (VirtualMachineError e) {
	SystemFailure.initiateFailure(e);
	throw e;
	} catch (Throwable t) {
	SystemFailure.checkFailure();
	throw new MBeanException(new Exception(t.getLocalizedMessage()));
	}
	}

	/**
	* It will call the Generic function to execute the method on the remote VM
	*/
	Object delegateToFunctionService(ObjectName objectName, String methodName, Object[] arguments,
	String[] signature) throws MBeanException {
	Object[] functionArguments = new Object[5];
	functionArguments[0] = objectName;
	functionArguments[1] = methodName;
	functionArguments[2] = signature;
	functionArguments[3] = arguments;
	functionArguments[4] = member.getName();

	List<Object> result;
	try {
	ResultCollector resultCollector = FunctionService.onMember(member)
	.setArguments(functionArguments)
	.execute(ManagementConstants.MGMT_FUNCTION_ID);
	result = (List<Object>) resultCollector.getResult();
	} catch (Exception e) {
	if (logger.isDebugEnabled()) {
	logger.debug(" Exception while Executing Function {}", e.getMessage(), e);
	}
	// Only in case of Exception caused for Function framework.
	return null;
	} catch (VirtualMachineError e) {
	SystemFailure.initiateFailure(e);
	throw e;
	} catch (Throwable t) {
	SystemFailure.checkFailure();
	if (logger.isDebugEnabled()) {
	logger.debug(" Error while Executing Function {}", t.getMessage(), t);
	}
	return null;
	}

	return checkErrors(result.get(ManagementConstants.RESULT_INDEX));
	}

	/**
	* As this proxy may behave as an notification emitter it delegates to the member
	* NotificationBroadcasterSupport object
	*/
	private void sendNotification(Object notification) {
	emitter.sendNotification((Notification) notification);
	}

	private Object checkErrors(Object lastResult) throws MBeanException {
	if (lastResult instanceof MBeanException) {
	// Convert all MBean public API exceptions to MBeanException
	throw (MBeanException) lastResult;
	}
	if (lastResult instanceof Exception) {
	return null;
	}
	if (lastResult instanceof Throwable) {
	return null;
	}
	return lastResult;
	}

	/**
	* The call will delegate to Managed Node for NotificationHub to register a local listener to
	* listen for notification from the MBean
	*
	* <p>
	* Moreover it will also add the client to local listener list by adding to the contained emitter.
	*/
	private Object invokeBroadcasterMethod(Method method, Object[] arguments)
	throws MBeanException, ListenerNotFoundException {
	String methodName = method.getName();
	int argumentCount = arguments == null ? 0 : arguments.length;

	Class[] parameterTypes = method.getParameterTypes();
	String[] signature = new String[parameterTypes.length];

	switch (methodName) {
	case "addNotificationListener": {
	// The various throws of IllegalArgumentException here should not happen, since we know what
	// the methods in NotificationBroadcaster and NotificationEmitter are.

	if (argumentCount != 3) {
	throw new IllegalArgumentException(
	"Bad arg count to addNotificationListener: " + argumentCount);
	}

	// Other inconsistencies will produce ClassCastException below.

	NotificationListener listener = (NotificationListener) arguments[0];
	NotificationFilter filter = (NotificationFilter) arguments[1];
	Object handback = arguments[2];
	emitter.addNotificationListener(listener, filter, handback);
	delegateToFunctionService(objectName, methodName, null, signature);
	return null;
	}

	case "removeNotificationListener": {
	// NullPointerException if method with no args, but that shouldn't happen because
	// removeNotificationListener does have args.
	NotificationListener listener = (NotificationListener) arguments[0];

	switch (argumentCount) {
	case 1:
	emitter.removeNotificationListener(listener);

	// No need to send listener and filter details to other members. We only need to send a
	// message saying remove the listener registered for this object on your side.

	delegateToFunctionService(objectName, methodName, null, signature);
	return null;

	case 3:
	NotificationFilter filter = (NotificationFilter) arguments[1];
	Object handback = arguments[2];
	emitter.removeNotificationListener(listener, filter, handback);

	delegateToFunctionService(objectName, methodName, null, signature);
	return null;

	default:
	throw new IllegalArgumentException(
	"Bad arg count to removeNotificationListener: " + argumentCount);
	}
	}

	case "getNotificationInfo":
	if (arguments != null) {
	throw new IllegalArgumentException("getNotificationInfo has " + "args");
	}

	if (!MBeanJMXAdapter.mbeanServer.isRegistered(objectName)) {
	return new MBeanNotificationInfo[0];
	}

	// MBean info is delegated to function service as intention is to get the info of the actual
	// mbean rather than the proxy

	Object obj = delegateToFunctionService(objectName, methodName, arguments, signature);
	if (obj instanceof String) {
	return new MBeanNotificationInfo[0];
	}
	MBeanInfo info = (MBeanInfo) obj;
	return info.getNotifications();

	default:
	throw new IllegalArgumentException("Bad method name: " + methodName);
	}
	}

	private boolean shouldDoLocally(Method method) {
	String methodName = method.getName();
	if ((methodName.equals("hashCode") \|\| methodName.equals("toString"))
	&& method.getParameterTypes().length == 0) {
	return true;
	}
	return methodName.equals("equals")
	&& Arrays.equals(method.getParameterTypes(), new Class[] {Object.class});
	}

	private Object doLocally(Method method, Object[] arguments) {
	String methodName = method.getName();
	FederationComponent federation =
	(FederationComponent) monitoringRegion.get(objectName.toString());

	switch (methodName) {
	case "equals":
	return federation.equals(arguments[0]);
	case "toString":
	return federation.toString();
	case "hashCode":
	return federation.hashCode();
	}

	throw new IllegalArgumentException("Unexpected method name: " + methodName);
	}

	private MXBeanProxyInvocationHandler findMXBeanProxy(ObjectName objectName,
	Class<?> mbeanInterface, MBeanProxyInvocationHandler handler) {
	if (mxBeanProxyInvocationHandler == null) {
	synchronized (this) {
	try {
	mxBeanProxyInvocationHandler =
	new MXBeanProxyInvocationHandler(objectName, mbeanInterface, handler);
	} catch (IllegalArgumentException e) {
	String message =
	"Cannot make MXBean proxy for " + mbeanInterface.getName() + ": " + e.getMessage();
	throw new IllegalArgumentException(message, e.getCause());
	}
	}
	}
	return mxBeanProxyInvocationHandler;
	}

	/**
	* Internal implementation of all the generic proxy methods
	*/
	private static class ProxyInterfaceImpl implements ProxyInterface {

	private volatile long lastRefreshedTime;

	private ProxyInterfaceImpl() {
	lastRefreshedTime = System.currentTimeMillis();
	}

	@Override
	public long getLastRefreshedTime() {
	return lastRefreshedTime;
	}

	@Override
	public void setLastRefreshedTime(long lastRefreshedTime) {
	this.lastRefreshedTime = lastRefreshedTime;
	}
	}
	}