org/objectweb/proactive/core/body/request/AwaitedRequest.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.body.request;

import java.io.IOException;

import org.apache.log4j.Logger;
import org.objectweb.proactive.Body;
import org.objectweb.proactive.ProActive;
import org.objectweb.proactive.core.UniqueID;
import org.objectweb.proactive.core.body.UniversalBody;
import org.objectweb.proactive.core.body.ft.exception.ProtocolErrorException;
import org.objectweb.proactive.core.body.ft.message.MessageInfo;
import org.objectweb.proactive.core.body.ft.protocols.FTManager;
import org.objectweb.proactive.core.body.reply.Reply;
import org.objectweb.proactive.core.exceptions.proxy.ProxyNonFunctionalException;
import org.objectweb.proactive.core.mop.MethodCall;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;
import org.objectweb.proactive.ext.security.ProActiveSecurityManager;
import org.objectweb.proactive.ext.security.exceptions.RenegotiateSessionException;


public class AwaitedRequest implements Request, java.io.Serializable {

    public static Logger logger = ProActiveLogger.getLogger(Loggers.REQUESTS);

    // awaited sender
    private UniqueID awaitedSender;

    // wrapped Request
    private Request wrappedRequest;
    private boolean isArrived;

    //Non Functional Requests
        protected boolean isNFRequest = false;
        protected int nfRequestPriority;

    public AwaitedRequest(UniqueID awaitedSender) {
        this.awaitedSender = awaitedSender;
        this.isArrived = false;
    }

    public synchronized void setAwaitedRequest(Request r) {
        //System.err.println("[AWAITED] Request is updated by " + this.awaitedSender + " with " + r);
        //if(!(r.getSourceBodyID().equals(this.awaitedSender))){
        //    logger.error(" **ERROR** : update request is not from the awaited sender !");
        //}
        this.wrappedRequest = r;
        this.isArrived = true;
        notifyAll();
    }

    public UniqueID getAwaitedSender() {
        return this.awaitedSender;
    }

    public Reply serve(Body targetBody) throws ServeException {
        waitForRequest();
        return wrappedRequest.serve(targetBody);
    }

    /*
     * Wait for a request from the awaited sender.
     */
    private synchronized void waitForRequest() {
        while (!isArrived) {
            try {
                //                //if (logger.isDebugEnabled()) {
                //                UniqueID waiter = ProActive.getBodyOnThis().getID();
                //                    logger.info("[WAIT] " + waiter + " is waiting for a request from " +
                //                        this.awaitedSender);
                //                //}
                this.wait(3000);

                if (!isArrived) {
                    UniqueID waiter = ProActive.getBodyOnThis().getID();
                    logger.info("[WAIT] " + waiter +
                        " is waiting for a request from " + this.awaitedSender);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public MethodCall getMethodCall() {
        if (this.isArrived) {
            return this.wrappedRequest.getMethodCall();
        } else {
            return null;
        }
    }

    public Object getParameter(int index) {
        return wrappedRequest.getParameter(index);
    }

    public UniversalBody getSender() {
        return wrappedRequest.getSender();
    }

    public boolean hasBeenForwarded() {
        return wrappedRequest.hasBeenForwarded();
    }

    public void resetSendCounter() {
        throw new ProtocolErrorException(
            "An active object is trying to send an awaited request");
    }

    public void notifyReception(UniversalBody bodyReceiver)
        throws IOException {
        wrappedRequest.notifyReception(bodyReceiver);
    }

    public int send(UniversalBody destinationBody)
        throws IOException, RenegotiateSessionException {
        throw new ProtocolErrorException(
            "An active object is trying to send an awaited request");
    }

    public String getMethodName() {
        if (!this.isArrived) {
            return "Awaited Request from " + this.awaitedSender;
        } else {
            return wrappedRequest.getMethodName();
        }
    }

    public UniqueID getSourceBodyID() {
        return this.awaitedSender;
    }

    public long getTimeStamp() {
        return wrappedRequest.getTimeStamp();
    }

    public boolean isOneWay() {
        return wrappedRequest.isOneWay();
    }

    public long getSequenceNumber() {
        if (!this.isArrived) {
            return 0;
        } else {
            return wrappedRequest.getSequenceNumber();
        }
    }

    public void setMessageInfo(MessageInfo mi) {
        wrappedRequest.setMessageInfo(mi);
    }

    public MessageInfo getMessageInfo() {
        if (!this.isArrived) {
            return null;
        } else {
            return wrappedRequest.getMessageInfo();
        }
    }

    public void setIgnoreIt(boolean ignore) {
        wrappedRequest.setIgnoreIt(ignore);
    }

    public boolean ignoreIt() {
        return wrappedRequest.ignoreIt();
    }

    public void setFTManager(FTManager ft) {
    }

    public FTManager getFTManager() {
        return null;
    }

    public Reply serveAlternate(Body targetBody, ProxyNonFunctionalException nfe) {
        return this.wrappedRequest.serveAlternate(targetBody, nfe);
    }

    public boolean isCiphered() {
        return this.wrappedRequest.isCiphered();
    }

    public long getSessionId() {
        return this.wrappedRequest.getSessionId();
    }

    public boolean decrypt(ProActiveSecurityManager psm)
        throws RenegotiateSessionException {
        return this.wrappedRequest.decrypt(psm);
    }

    public boolean crypt(ProActiveSecurityManager psm,
        UniversalBody destinationBody) throws RenegotiateSessionException {
        return this.wrappedRequest.crypt(psm, destinationBody);
    }
    
    //
    // -- Methods dealing with Non Functional Requests
    //
    
        public boolean isFunctionalRequest() {
                return isNFRequest;
        }

        public void setFunctionalRequest(boolean isFunctionalRequest) {
           this.isNFRequest = isFunctionalRequest; 
        }

        public void setNFRequestPriority(int nfReqPriority) {
                this.nfRequestPriority = nfReqPriority;
        }

        public int getNFRequestPriority() {
                return nfRequestPriority;
        }
}

---