org/objectweb/proactive/Service.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;

import org.objectweb.fractal.api.NoSuchInterfaceException;
import org.objectweb.fractal.api.control.LifeCycleController;
import org.objectweb.fractal.util.Fractal;
import org.objectweb.proactive.core.ProActiveRuntimeException;
import org.objectweb.proactive.core.body.request.BlockingRequestQueue;
import org.objectweb.proactive.core.body.request.Request;
import org.objectweb.proactive.core.body.request.RequestFilter;
import org.objectweb.proactive.core.body.request.RequestProcessor;
import org.objectweb.proactive.core.component.body.ComponentBody;


public class Service {
    //
    // -- PROTECTED MEMBERS -----------------------------------------------
    //
    protected Body body;
    protected BlockingRequestQueue requestQueue;

    protected LifeCycleController lifeCycleController = null;

    //protected RequestFilterOnMethodName requestFilterOnMethodName = null;
    //
    // -- CONSTRUCTORS -----------------------------------------------
    //

    public Service(Body body) {
        this.body = body;
        this.requestQueue = body.getRequestQueue();
        if (((ComponentBody) body).isComponent()) {
            try {
                lifeCycleController = Fractal.getLifeCycleController(((ComponentBody) body).getProActiveComponentImpl());
            } catch (NoSuchInterfaceException e) {
                throw new ProActiveRuntimeException("could not find the life cycle controller for this component");
            }
        }
    }

    //
    // -- PUBLIC METHODS -----------------------------------------------
    //
    public String toString() {
        return "Service\n  Body=" + body.toString() + "\n  RequestQueue=" +
        requestQueue.toString();
    }

    public void serve(Request request) {
        body.serve(request);
    }

    public void fifoServing() {
        if (((ComponentBody) body).isComponent()) {
            while (LifeCycleController.STARTED.equals(
                        lifeCycleController.getFcState())) {
                blockingServeOldest();
            }
        } else {
            while (body.isActive()) {
                blockingServeOldest();
            }
        }
    }

    public void lifoServing() {
        while (body.isActive()) {
            blockingServeYoungest();
        }
    }

    // -- Serve Oldest ---------------------------------------------------

    public void blockingServeOldest() {
        blockingServeOldest(null, 0);
    }

    public void blockingServeOldest(long timeout) {
        blockingServeOldest(null, timeout);
    }

    public void blockingServeOldest(RequestFilter requestFilter, long timeout) {
        body.serve(requestQueue.blockingRemoveOldest(requestFilter, timeout));
    }

    public void blockingServeOldest(String methodName) {
        blockingServeOldest(new RequestFilterOnMethodName(methodName));
    }

    public void blockingServeOldest(RequestFilter requestFilter) {
        blockingServeOldest(requestFilter, 0);
    }

    public void serveOldest() {
        body.serve(requestQueue.removeOldest());
    }

    public void serveOldest(String methodName) {
        body.serve(requestQueue.removeOldest(methodName));
    }

    public void serveOldest(RequestFilter requestFilter) {
        body.serve(requestQueue.removeOldest(requestFilter));
    }

    // -- Serve Youngest ---------------------------------------------------

    public void blockingServeYoungest() {
        blockingServeYoungest(null, 0);
    }

    public void blockingServeYoungest(long timeout) {
        blockingServeYoungest(null, timeout);
    }

    public void blockingServeYoungest(String methodName) {
        blockingServeYoungest(new RequestFilterOnMethodName(methodName));
    }

    public void blockingServeYoungest(RequestFilter requestFilter) {
        blockingServeYoungest(requestFilter, 0);
    }

    public void blockingServeYoungest(RequestFilter requestFilter, long timeout) {
        body.serve(requestQueue.blockingRemoveYoungest(requestFilter, timeout));
    }

    public void serveYoungest() {
        body.serve(requestQueue.removeYoungest());
    }

    public void serveYoungest(String methodName) {
        body.serve(requestQueue.removeYoungest(methodName));
    }

    public void serveYoungest(RequestFilter requestFilter) {
        body.serve(requestQueue.removeYoungest(requestFilter));
    }

    // -- Serve All ---------------------------------------------------

    public void serveAll(String methodName) {
        serveAll(new RequestFilterOnMethodName(methodName));
    }

    public void serveAll(RequestFilter requestFilter) {
        requestQueue.processRequests(new ServingRequestProcessor(requestFilter),
            body);
    }

    // -- Serve And Flush Youngest ---------------------------------------------------

    public void flushingServeYoungest() {
        flushingServeYoungest(new AcceptAllRequestFilter());
    }

    public void flushingServeYoungest(String methodName) {
        flushingServeYoungest(new RequestFilterOnMethodName(methodName));
    }

    public void flushingServeYoungest(RequestFilter requestFilter) {
        requestQueue.processRequests(new FlushingServeYoungestRequestProcessor(
                requestFilter), body);
    }

    // -- Serve And Flush Oldest ---------------------------------------------------

    public void flushingServeOldest() {
        flushingServeOldest(new AcceptAllRequestFilter());
    }

    public void flushingServeOldest(String methodName) {
        flushingServeOldest(new RequestFilterOnMethodName(methodName));
    }

    public void flushingServeOldest(RequestFilter requestFilter) {
        requestQueue.processRequests(new FlushingServeOldestRequestProcessor(
                requestFilter), body);
    }

    // -- Other helpers methods ---------------------------------------------------

    public void waitForRequest() {
        requestQueue.waitForRequest();
    }

    public boolean hasRequestToServe() {
        return !requestQueue.isEmpty();
    }

    public boolean hasRequestToServe(String methodName) {
        return requestQueue.hasRequest(methodName);
    }

    public int getRequestCount() {
        return requestQueue.size();
    }

    public void flushAll() {
        requestQueue.clear();
    }

    //
    // -- getOldests ---------------------------------------------------
    //

    public Request getOldest() {
        return requestQueue.getOldest();
    }

    public Request getOldest(String methodName) {
        return requestQueue.getOldest(methodName);
    }

    public Request getOldest(RequestFilter requestFilter) {
        return requestQueue.getOldest(requestFilter);
    }

    public Request blockingGetOldest() {
        Request request = null;
        while ((request == null) && !requestQueue.isDestroyed()) {
            waitForRequest();
            request = requestQueue.getOldest();
        }
        return request;
    }

    //
    // -- getYoungests ---------------------------------------------------
    //

    public Request getYoungest() {
        return requestQueue.getYoungest();
    }

    public Request getYoungest(String methodName) {
        return requestQueue.getYoungest(methodName);
    }

    public Request getYoungest(RequestFilter requestFilter) {
        return requestQueue.getYoungest(requestFilter);
    }

    public Request blockingGetYoungest() {
        Request request = null;
        while ((request == null) && !requestQueue.isDestroyed()) {
            waitForRequest();
            request = requestQueue.getYoungest();
        }
        return request;
    }

    //
    // -- blockingRemoveOldests ---------------------------------------------------
    //

    public Request blockingRemoveOldest(RequestFilter requestFilter) {
        return blockingRemoveOldest(requestFilter, 0);
    }

    public Request blockingRemoveOldest(RequestFilter requestFilter,
        long timeout) {
        return requestQueue.blockingRemoveOldest(requestFilter, timeout);
    }

    public Request blockingRemoveOldest(String methodName) {
        return blockingRemoveOldest(new RequestFilterOnMethodName(methodName), 0);
    }

    public Request blockingRemoveOldest() {
        return blockingRemoveOldest(null, 0);
    }

    public Request blockingRemoveOldest(long timeout) {
        return blockingRemoveOldest(null, timeout);
    }

    //
    // -- blockingRemoveYoungests ---------------------------------------------------
    //

    public Request blockingRemoveYoungest(RequestFilter requestFilter) {
        return blockingRemoveYoungest(requestFilter, 0);
    }

    public Request blockingRemoveYoungest(RequestFilter requestFilter,
        long timeout) {
        return requestQueue.blockingRemoveYoungest(requestFilter, timeout);
    }

    public Request blockingRemoveYoungest(String methodName) {
        return blockingRemoveYoungest(new RequestFilterOnMethodName(methodName),
            0);
    }

    public Request blockingRemoveYoungest() {
        return blockingRemoveYoungest(null, 0);
    }

    public Request blockingRemoveYoungest(long timeout) {
        return blockingRemoveYoungest(null, timeout);
    }

    //
    // -- INNER CLASSES -----------------------------------------------
    //

    protected class ServingRequestProcessor implements RequestProcessor {

        private RequestFilter selectorRequestFilter;

        public ServingRequestProcessor(RequestFilter selectorRequestFilter) {
            this.selectorRequestFilter = selectorRequestFilter;
        }

        public int processRequest(Request request) {
            if (selectorRequestFilter.acceptRequest(request)) {
                return REMOVE_AND_SERVE;
            } else {
                return KEEP;
            }
        }
    } // end inner class ServingRequestProcessor

    protected class FlushingServeYoungestRequestProcessor
        implements RequestProcessor {
        private RequestFilter selectorRequestFilter;
        private Request requestToServe;
        private int counter;
        private int numberOfRequests;

        public FlushingServeYoungestRequestProcessor(
            RequestFilter selectorRequestFilter) {
            this.selectorRequestFilter = selectorRequestFilter;
        }

        public int processRequest(Request request) {
            if (counter == 0) {
                // first call
                numberOfRequests = requestQueue.size();
            }
            counter++;
            int shouldRemove;
            if (selectorRequestFilter.acceptRequest(request)) {
                requestToServe = request;
                shouldRemove = REMOVE;
            } else {
                shouldRemove = KEEP;
            }
            if ((counter == numberOfRequests) && (requestToServe != null)) {
                if (request == requestToServe) {
                    return REMOVE_AND_SERVE; // serve current request
                } else {
                    body.serve(requestToServe); // serve an already removed request
                }
            }
            return shouldRemove;
        }
    } // end inner class FlushingServeYoungestRequestProcessor

    protected class FlushingServeOldestRequestProcessor
        implements RequestProcessor {
        private RequestFilter selectorRequestFilter;
        private boolean hasServed;

        public FlushingServeOldestRequestProcessor(
            RequestFilter selectorRequestFilter) {
            this.selectorRequestFilter = selectorRequestFilter;
        }

        public int processRequest(Request request) {
            if (selectorRequestFilter.acceptRequest(request)) {
                if (!hasServed) {
                    hasServed = true;
                    return REMOVE_AND_SERVE;
                }
                return REMOVE;
            } else {
                return KEEP;
            }
        }
    } // end inner class FlushingServeYoungestRequestProcessor

    protected class RequestFilterOnMethodName implements RequestFilter,
        java.io.Serializable {
        private String methodName;

        public RequestFilterOnMethodName(String methodName) {
            this.methodName = methodName;
        }

        public boolean acceptRequest(Request request) {
            return methodName.equals(request.getMethodName());
        }
    }

    protected class AcceptAllRequestFilter implements RequestFilter {

        public boolean acceptRequest(Request request) {
            return true;
        }
    } // end inner class AcceptAllRequestFilter
}

---