org/objectweb/proactive/core/mop/MethodCall.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library 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 any later version.
 *  
 * This library 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 library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.mop;

import java.io.ByteArrayInputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

import org.apache.log4j.Logger;
import org.objectweb.proactive.ProActive;
import org.objectweb.proactive.core.component.ComponentMethodCallMetadata;
import org.objectweb.proactive.core.component.representative.ItfID;
import org.objectweb.proactive.core.component.request.ComponentRequest;
import org.objectweb.proactive.core.exceptions.manager.ExceptionHandler;
import org.objectweb.proactive.core.util.ObjectToByteConverter;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;

import sun.rmi.server.MarshalInputStream;


public class MethodCall implements java.io.Serializable, Cloneable {
    

    //
    // --- STATIC MEMBERS -----------------------------------------------------------------------
    //

    private static transient java.util.Hashtable<String, ReifiableAndExceptions> REIF_AND_EXCEP = new java.util.Hashtable<String, ReifiableAndExceptions>();
    static Logger logger = ProActiveLogger.getLogger(Loggers.MOP);

    private static int RECYCLE_POOL_SIZE = 30;

    private static MethodCall[] recyclePool;

    private static int index;

    private static boolean recycleMethodCallObject;
    private static java.util.Hashtable<String, Method> reifiedMethodsTable = new java.util.Hashtable<String, Method>();

    static {
        MethodCall.setRecycleMethodCallObject(true);
    }

    //
    // --- PRIVATE MEMBERS -----------------------------------------------------------------------
    //

    private Object[] effectiveArguments;

    private LinkedList<String> tagsForBarrier = null;

    private transient Method reifiedMethod;

    private long methodCallID;
    private String key;

    private transient MethodCallExceptionContext exceptioncontext;

    ComponentMethodCallMetadata componentMetaData = null;
    
    private transient Map<TypeVariable, Class> genericTypesMapping = null;


    private byte[] serializedEffectiveArguments = null;

    public void transformEffectiveArgumentsIntoByteArray() {
        if ((serializedEffectiveArguments == null) &&
                (effectiveArguments != null)) {
            try {
                //                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                //
                //                //  ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
                //                MarshalOutputStream objectOutputStream = new MarshalOutputStream(byteArrayOutputStream);
                //                objectOutputStream.writeObject(effectiveArguments);
                //                objectOutputStream.flush();
                //                objectOutputStream.close();
                //                byteArrayOutputStream.close();
                //                serializedEffectiveArguments = byteArrayOutputStream.toByteArray();
                serializedEffectiveArguments = ObjectToByteConverter.convert(effectiveArguments);
            } catch (Exception e) {
                e.printStackTrace();
            }
            effectiveArguments = null;
        }
    }

    public static synchronized void setRecycleMethodCallObject(boolean value) {
        if (recycleMethodCallObject == value) {
            return;
        } else {
            recycleMethodCallObject = value;
            if (value) {
                // Creates the recycle poll for MethodCall objects
                recyclePool = new MethodCall[RECYCLE_POOL_SIZE];
                index = 0;
            } else {
                // If we do not want to recycle MethodCall objects anymore,
                // let's free some memory by permitting the reyclePool to be
                // garbage-collecting
                recyclePool = null;
            }
        }
    }

    public static synchronized boolean getRecycleMethodCallObject() {
        return MethodCall.recycleMethodCallObject;
    }

    public synchronized static MethodCall getMethodCall(Method reifiedMethod, Map<TypeVariable,Class> genericTypesMapping,
        Object[] effectiveArguments, MethodCallExceptionContext exceptioncontext) {
        exceptioncontext = MethodCallExceptionContext.optimize(exceptioncontext);

        if (MethodCall.getRecycleMethodCallObject()) {
            // Finds a recycled MethodCall object in the pool, cleans it and
            // eventually returns it
            if (MethodCall.index > 0) {
                // gets the object from the pool
                MethodCall.index--;
                MethodCall result = MethodCall.recyclePool[MethodCall.index];
                MethodCall.recyclePool[MethodCall.index] = null;
                // Refurbishes the object
                result.reifiedMethod = reifiedMethod;
                result.genericTypesMapping = genericTypesMapping;
                result.effectiveArguments = effectiveArguments;
                result.key = buildKey(reifiedMethod, genericTypesMapping);
                result.exceptioncontext = exceptioncontext;
                return result;
            }
        }
        return new MethodCall(reifiedMethod, genericTypesMapping, effectiveArguments, exceptioncontext);
    }

    public synchronized static MethodCall getMethodCall(Method reifiedMethod,
        Object[] effectiveArguments, Map<TypeVariable,Class> genericTypesMapping) {
        MethodCallExceptionContext exceptioncontext = ExceptionHandler.getContextForCall(reifiedMethod);
        return getMethodCall(reifiedMethod, genericTypesMapping, effectiveArguments, exceptioncontext);
    }

    public synchronized static MethodCall getComponentMethodCall(
        Method reifiedMethod,  Object[] effectiveArguments, Map<TypeVariable,Class> genericTypesMapping,
        String interfaceName, ItfID senderItfID, short priority) {
        MethodCall mc = getMethodCall(reifiedMethod, effectiveArguments, genericTypesMapping);
        
        mc.componentMetaData = new ComponentMethodCallMetadata();
        mc.componentMetaData.setComponentInterfaceName(interfaceName);
        mc.componentMetaData.setSenderItfID(senderItfID);
        mc.componentMetaData.setPriority(priority);
        mc.componentMetaData.setShortcut(null);
        return mc;
    }

    public synchronized static MethodCall getComponentMethodCall(
        Method reifiedMethod, Object[] effectiveArguments,Map<TypeVariable,Class> genericTypesMapping, 
        String interfaceName, ItfID senderItfID ) {
        return MethodCall.getComponentMethodCall(reifiedMethod,
                        effectiveArguments, genericTypesMapping, interfaceName, senderItfID,
            ComponentRequest.STRICT_FIFO_PRIORITY);
    }

    public synchronized static void setMethodCall(MethodCall mc) {
        if (MethodCall.getRecycleMethodCallObject()) {
            // If there's still one slot left in the pool
            if (MethodCall.recyclePool[MethodCall.index] == null) {
                // Cleans up a MethodCall object
                // It is prefereable to do it here rather than at the moment
                // the object is picked out of the pool, because it allows
                // garbage-collecting the objects referenced in here
                mc.componentMetaData = null;
                mc.reifiedMethod = null;
                mc.genericTypesMapping = null;
                mc.effectiveArguments = null;
                mc.tagsForBarrier = null;
                mc.key = null;
                mc.exceptioncontext = null;
                // Inserts the object in the pool
                MethodCall.recyclePool[MethodCall.index] = mc;
                MethodCall.index++;
                if (MethodCall.index == RECYCLE_POOL_SIZE) {
                    MethodCall.index = RECYCLE_POOL_SIZE - 1;
                }
            }
        }
    }

    // This constructor is private to this class
    // because we want to enforce the use of factory methods for getting fresh
    // instances of this class (see <I>Factory</I> pattern in GoF).
    public MethodCall(Method reifiedMethod, Map<TypeVariable,Class> genericTypesMapping, Object[] effectiveArguments, 
        MethodCallExceptionContext exceptionContext) {
        this.reifiedMethod = reifiedMethod;
        this.genericTypesMapping = (genericTypesMapping!=null && genericTypesMapping.size()>0)?genericTypesMapping:null;
        this.effectiveArguments = effectiveArguments;
        this.key = buildKey(reifiedMethod, genericTypesMapping);
        this.exceptioncontext = MethodCallExceptionContext.optimize(exceptionContext);
    }

    public MethodCall(Method reifiedMethod, Map<TypeVariable,Class> genericTypesMapping, Object[] effectiveArguments) {
        this(reifiedMethod, genericTypesMapping, effectiveArguments, null);
    }

    public MethodCall(MethodCall mc) {
        try {
            this.componentMetaData = mc.componentMetaData;
            this.reifiedMethod = mc.getReifiedMethod();
            if (mc.serializedEffectiveArguments == null) {
                serializedEffectiveArguments = null;
            } else {
                // array copy
                byte[] source = mc.serializedEffectiveArguments;
                serializedEffectiveArguments = new byte[source.length];
                for (int i = 0; i < serializedEffectiveArguments.length; i++) {
                    serializedEffectiveArguments[i] = source[i];
                }
            }
            if (mc.effectiveArguments == null) {
                effectiveArguments = null;
            } else {
                effectiveArguments = (Object[]) Utils.makeDeepCopy(mc.effectiveArguments);
            }
            this.genericTypesMapping = mc.getGenericTypesMapping();
            this.key = MethodCall.buildKey(mc.getReifiedMethod(), mc.getGenericTypesMapping());
            this.exceptioncontext = mc.exceptioncontext;
            // methodcallID?
        } catch (java.io.IOException e) {
            e.printStackTrace();
        }
    }

    protected MethodCall() {
        this.reifiedMethod = null;
        this.effectiveArguments = null;
        this.serializedEffectiveArguments = null;
        this.exceptioncontext = null;
    }

    public Object execute(Object targetObject)
        throws InvocationTargetException, MethodCallExecutionFailedException {
        // A test at how non-public methods can be reflected
        if ((serializedEffectiveArguments != null) &&
                (effectiveArguments == null)) {
            try {
                ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(serializedEffectiveArguments);

                //ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
                MarshalInputStream objectInputStream = new MarshalInputStream(byteArrayInputStream);
                effectiveArguments = (Object[]) objectInputStream.readObject();
                objectInputStream.close();
                byteArrayInputStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            serializedEffectiveArguments = null;
        }
        if (logger.isDebugEnabled()) {
            logger.debug("MethodCall.execute() name = " + this.getName());
            logger.debug("MethodCall.execute() reifiedMethod = " +
                reifiedMethod);
            logger.debug(
                "MethodCall.execute() reifiedMethod.getDeclaringClass() = " +
                reifiedMethod.getDeclaringClass());
            logger.debug("MethodCall.execute() targetObject " + targetObject);
        }
        if (reifiedMethod.getParameterTypes().length > 0) {
            reifiedMethod.setAccessible(true);
        }
        try {
            targetObject = ProActive.getFutureValue(targetObject);
            return reifiedMethod.invoke(targetObject, effectiveArguments);
        } catch (IllegalAccessException e) {
            throw new MethodCallExecutionFailedException(
                "Access rights to the method denied: " + e);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
            throw new MethodCallExecutionFailedException(
                "Arguments for the method " + this.getName() +
                " are invalids: " + e);
        } /*catch (InvocationTargetException e) {
        throw new MethodCallExecutionFailedException(
        "Target for invocation of " + this.getName() +
        " is invalid: " + e);
        }*/}

    protected void finalize() {
        MethodCall.setMethodCall(this);
    }

    public Method getReifiedMethod() {
        return reifiedMethod;
    }

    public String getName() {
        return reifiedMethod.getName();
    }

    public int getNumberOfParameter() {
        return this.effectiveArguments.length;
    }

    public Object getParameter(int index) {
        return this.effectiveArguments[index];
    }

    public Object[] getParameters() {
        return this.effectiveArguments;
    }

    public void setEffectiveArguments(Object[] o) {
        effectiveArguments = o;
    }

    public Object[] getEffectiveArguments() {
        return effectiveArguments;
    }

    public void makeDeepCopyOfArguments() throws java.io.IOException {
        effectiveArguments = (Object[]) Utils.makeDeepCopy(effectiveArguments);
    }

    //
    // --- PRIVATE METHODS -----------------------------------------------------------------------
    //
    private Class[] fixBugRead(FixWrapper[] para) {
        Class[] tmp = new Class[para.length];
        for (int i = 0; i < para.length; i++) {
            //  System.out.println("fixBugRead for " + i + " value is " +para[i]);
            tmp[i] = para[i].getWrapped();
        }
        return tmp;
    }

    private FixWrapper[] fixBugWrite(Class[] para) {
        FixWrapper[] tmp = new FixWrapper[para.length];
        for (int i = 0; i < para.length; i++) {
            //  System.out.println("fixBugWrite for " + i + " out of " + para.length + " value is " +para[i] ); 
            tmp[i] = new FixWrapper(para[i]);
        }
        return tmp;
    }

    // build a key for uniquely identifying methods, including parameterized ones
    private static String buildKey(Method reifiedMethod, Map<TypeVariable, Class> genericTypesMapping) {
        String sb = "";
        sb+=(reifiedMethod.getDeclaringClass().getName());
        // return type
        Type returnType = reifiedMethod.getGenericReturnType();
        if (genericTypesMapping!=null && genericTypesMapping.containsKey(returnType)) {
                sb+=genericTypesMapping.get(returnType);
        } else {
                sb+=returnType;
        }
        sb+=(reifiedMethod.getName());
        // params
        Type[] parameters = reifiedMethod.getGenericParameterTypes();
        for (int i = 0; i < parameters.length; i++) {
            sb+=((genericTypesMapping!=null && genericTypesMapping.containsKey(parameters[i]))?genericTypesMapping.get(parameters[i]).getName():parameters[i]);
        }
        
        return sb.toString();
    }

    //
    // --- PRIVATE METHODS FOR SERIALIZATION --------------------------------------------------------------
    //
    private void writeObject(java.io.ObjectOutputStream out)
        throws java.io.IOException {
        this.writeTheObject(out);
    }

    protected void writeTheObject(java.io.ObjectOutputStream out)
        throws java.io.IOException {
        out.defaultWriteObject();
        // The Method object needs to be converted
        out.writeObject(reifiedMethod.getDeclaringClass());
        out.writeObject(reifiedMethod.getName());
        out.writeObject(fixBugWrite(reifiedMethod.getParameterTypes()));
    }

    private void readObject(java.io.ObjectInputStream in)
        throws java.io.IOException, ClassNotFoundException {
        this.readTheObject(in);
    }

    protected void readTheObject(java.io.ObjectInputStream in)
        throws java.io.IOException, ClassNotFoundException {
        in.defaultReadObject();
        reifiedMethod = (Method) reifiedMethodsTable.get(key);
        if (reifiedMethod == null) {
            // Reads several pieces of data that we need for looking up the method
            Class declaringClass = (Class) in.readObject();
            String simpleName = (String) in.readObject();
            Class[] parameters = this.fixBugRead((FixWrapper[]) in.readObject());

            // Looks up the method
            try {
                reifiedMethod = declaringClass.getMethod(simpleName, parameters);
                reifiedMethodsTable.put(key, reifiedMethod);
            } catch (NoSuchMethodException e) {
                throw new InternalException("Lookup for method failed: " + e +
                    ". This may be caused by having different versions of the same class on different VMs. Check your CLASSPATH settings.");
            }
        } else { //added to avoid an ibis bug
            in.readObject();
            in.readObject();
            in.readObject();
        }
        if ((serializedEffectiveArguments != null) &&
                (effectiveArguments == null)) {
            try {
                ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(serializedEffectiveArguments);

                //          ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
                MarshalInputStream objectInputStream = new MarshalInputStream(byteArrayInputStream);
                effectiveArguments = (Object[]) objectInputStream.readObject();
                objectInputStream.close();
                byteArrayInputStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            serializedEffectiveArguments = null;
        }
    }

    public boolean isOneWayCall() {
        return this.getReifiedMethod().getReturnType().equals(java.lang.Void.TYPE) &&
        (this.getReifiedMethod().getExceptionTypes().length == 0) &&
        !this.getExceptionContext().isRuntimeExceptionHandled();
    }

    /* Used in the REIF_AND_EXCEP cache */
    static class ReifiableAndExceptions {
        boolean reifiable; // Is the method return type reifiable ?
        boolean exceptions; // Does the method throws exceptions ?
        String reason; // Why is the method synchronous ? null if it is asynchronous
    }

    public String getSynchronousReason() {
        Method m = this.getReifiedMethod();
        ReifiableAndExceptions cached = (ReifiableAndExceptions) REIF_AND_EXCEP.get(key);
        if (cached == null) {
            cached = new ReifiableAndExceptions();
            /* void is reifiable even though the check by the MOP would tell otherwise */
            cached.reifiable = m.getReturnType().equals(java.lang.Void.TYPE);
            if (!cached.reifiable) {
                try {
                        if (getGenericTypesMapping()!=null && getGenericTypesMapping().containsKey(m.getGenericReturnType())) {
                                // if return type is a parameterized type, check with actual parameterizing type
                                MOP.checkClassIsReifiable(getGenericTypesMapping().get(m.getGenericReturnType()));
                        } else {
                                MOP.checkClassIsReifiable(m.getReturnType());
                        }
                    cached.reifiable = true;
                } catch (ClassNotReifiableException e) {
                    cached.reason = e.getMessage();
                }
            }

            cached.exceptions = m.getExceptionTypes().length != 0;
            if (cached.exceptions) {
                cached.reason = "The method can throw a checked exception";
            }
            REIF_AND_EXCEP.put(key, cached);
        }

        if (cached.reifiable && cached.exceptions && getExceptionContext().isExceptionAsynchronously()) {
                /* ProActive.tryWithCatch() is used, so this call is asynchronous */
                return null;
        }

        return cached.reason;
    }

    public boolean isAsynchronousWayCall() {
        return getSynchronousReason() == null;
    }

    public void setBarrierTags(LinkedList<String> barrierTags) {
        this.tagsForBarrier = new LinkedList<String>();
        Iterator<String> it = barrierTags.iterator();
        while (it.hasNext()) {
            this.tagsForBarrier.add(new String(it.next()));
        }
    }

    public LinkedList getBarrierTags() {
        return this.tagsForBarrier;
    }

    public MethodCallExceptionContext getExceptionContext() {
        if (exceptioncontext == null) {
            return MethodCallExceptionContext.DEFAULT;
        }

        return exceptioncontext;
    }
    
    public ComponentMethodCallMetadata getComponentMetadata() {
        return componentMetaData;
    }
    
    public Map<TypeVariable, Class> getGenericTypesMapping() {
        return genericTypesMapping;
    }
    

    //
    // --- INNER CLASSES -----------------------------------------------------------------------
    //
    public class FixWrapper implements java.io.Serializable {
        public boolean isPrimitive;
        public Class encapsulated;

        public FixWrapper() {
        }

        public FixWrapper(Class c) {
            if (!c.isPrimitive()) {
                encapsulated = c;
                return;
            }
            isPrimitive = true;
            if (c.equals(Boolean.TYPE)) {
                encapsulated = Boolean.class;
            } else if (c.equals(Byte.TYPE)) {
                encapsulated = Byte.class;
            } else if (c.equals(Character.TYPE)) {
                encapsulated = Character.class;
            } else if (c.equals(Double.TYPE)) {
                encapsulated = Double.class;
            } else if (c.equals(Float.TYPE)) {
                encapsulated = Float.class;
            } else if (c.equals(Integer.TYPE)) {
                encapsulated = Integer.class;
            } else if (c.equals(Long.TYPE)) {
                encapsulated = Long.class;
            } else if (c.equals(Short.TYPE)) {
                encapsulated = Short.class;
            }
        }

        public Class getWrapped() {
            if (!isPrimitive) {
                return encapsulated;
            }
            if (encapsulated.equals(Boolean.class)) {
                return Boolean.TYPE;
            }
            if (encapsulated.equals(Byte.class)) {
                return Byte.TYPE;
            }
            if (encapsulated.equals(Character.class)) {
                return Character.TYPE;
            }
            if (encapsulated.equals(Double.class)) {
                return Double.TYPE;
            }
            if (encapsulated.equals(Float.class)) {
                return Float.TYPE;
            }
            if (encapsulated.equals(Integer.class)) {
                return Integer.TYPE;
            }
            if (encapsulated.equals(Long.class)) {
                return Long.TYPE;
            }
            if (encapsulated.equals(Short.class)) {
                return Short.TYPE;
            }
            throw new InternalException("FixWrapper encapsulated class unkown " +
                encapsulated);
        }

        public String toString() {
            return "FixWrapper: " + encapsulated.toString();
        }
    }
    


    // end inner class FixWrapper
}

---