org/objectweb/proactive/core/descriptor/services/P2PDescriptorService.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.descriptor.services;

import java.util.Vector;

import org.apache.log4j.Logger;
import org.objectweb.proactive.core.ProActiveException;
import org.objectweb.proactive.core.node.Node;
import org.objectweb.proactive.core.node.NodeFactory;
import org.objectweb.proactive.core.runtime.ProActiveRuntime;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;
import org.objectweb.proactive.p2p.service.P2PService;
import org.objectweb.proactive.p2p.service.StartP2PService;
import org.objectweb.proactive.p2p.service.util.P2PConstants;


public class P2PDescriptorService implements UniversalService, P2PConstants {
    private static final Logger logger = ProActiveLogger.getLogger(Loggers.P2P_DESC_SERV);
    protected static String serviceName = P2P_NODE_NAME;
    protected int askedNodes = 0;
    protected P2PService serviceP2P;
    private Vector peerList;
    protected String nodeFamilyRegexp = null;

    public P2PDescriptorService() {
    }

    public ProActiveRuntime[] startService() throws ProActiveException {
        if (serviceP2P == null) {
            // Testing  if a P2P ssrvice is already running ?
            P2PService precedentService = this.getPrecedentService();
            if (precedentService != null) {
                // Keep precedent
                this.serviceP2P = precedentService;
                this.serviceP2P.firstContact(this.peerList);
            } else {
                // Start a new one
                StartP2PService startServiceP2P = new StartP2PService(this.peerList);
                startServiceP2P.start();
                this.serviceP2P = startServiceP2P.getP2PService();
            }
        }

        //return this.serviceP2P.getNodes(askedNodes);
        return null;
    }

    private P2PService getPrecedentService() {
        String url = System.getProperty(PROPERTY_ACQUISITION) +
            "://localhost:" + System.getProperty(PROPERTY_PORT) + "/" +
            P2P_NODE_NAME;
        try {
            Node serviceNode = NodeFactory.getNode(url);
            Object[] ao = serviceNode.getActiveObjects(P2PService.class.getName());
            if (ao.length == 1) {
                if (logger.isInfoEnabled()) {
                    logger.info("A precedent P2P service is running");
                }
                return (P2PService) ao[0];
            } else {
                if (logger.isInfoEnabled()) {
                    logger.info("No P2P service is runned");
                }
                return null;
            }
        } catch (Exception e) {
            if (logger.isInfoEnabled()) {
                logger.info("No P2P service is runned");
            }
            return null;
        }
    }

    public int getNodeNumber() {
        return askedNodes;
    }

    public void setNodeNumber(int nodeNumber) {
        this.askedNodes = nodeNumber;
    }

    public void setNodeNumberToMAX() {
        this.askedNodes = MAX_NODE;
    }

    public String getServiceName() {
        return serviceName;
    }

    public void setAcq(String acq) {
        System.setProperty(PROPERTY_ACQUISITION, acq);
    }

    public void setPort(String port) {
        System.setProperty(PROPERTY_PORT, port);
    }

    public void setNoa(String noa) {
        System.setProperty(PROPERTY_NOA, noa);
    }

    public void setTtu(String ttu) {
        System.setProperty(PROPERTY_TTU, ttu);
    }

    public void setTtl(String ttl) {
        System.setProperty(PROPERTY_TTL, ttl);
    }

    public void setMultiProcNodes(String multi_proc_nodes) {
        System.setProperty(PROPERTY_MULTI_PROC_NODES, multi_proc_nodes);
    }

    public void setXmlPath(String xml_path) {
        System.setProperty(PROPERPY_XML_PATH, xml_path);
    }

    public void setPeerList(String[] peerList) {
        this.peerList = new Vector();
        for (int i = 0; i < peerList.length; i++) {
            this.peerList.add(peerList[i]);
        }
    }

    public int getMAX() {
        return MAX_NODE;
    }

    public P2PService getP2PService() {
        return this.serviceP2P;
    }

        public void setNodeFamilyRegexp(String nodeFamilyRegexp) {
                this.nodeFamilyRegexp = nodeFamilyRegexp;
        }
        
        public String getNodeFamilyRegexp() {
                return this.nodeFamilyRegexp;
        }
}

---