sjero.net Git - linphone/blob - p2pproxy/src/org/linphone/p2pproxy/core/GenericService.java

   1 /*
   2 p2pproxy Copyright (C) 2007  Jehan Monnier ()
   3
   4 RtpRelayService.java - .
   5
   6 This program is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU General Public License
   8 as published by the Free Software Foundation; either version 2
   9 of the License, or (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19 */
  20 package org.linphone.p2pproxy.core;
  21
  22 import java.io.IOException;
  23 import java.net.Socket;
  24 import java.net.URI;
  25 import java.util.concurrent.ExecutorService;
  26 import java.util.concurrent.Executors;
  27
  28 import net.jxta.document.AdvertisementFactory;
  29 import net.jxta.id.IDFactory;
  30
  31 import net.jxta.platform.ModuleClassID;
  32 import net.jxta.platform.ModuleSpecID;
  33 import net.jxta.protocol.ModuleClassAdvertisement;
  34 import net.jxta.protocol.ModuleSpecAdvertisement;
  35 import net.jxta.protocol.PipeAdvertisement;
  36 import net.jxta.socket.JxtaServerSocket;
  37
  38 import org.apache.log4j.Logger;
  39 import org.linphone.p2pproxy.api.P2pProxyException;
  40
  41
  42 public class GenericService implements Runnable,ServiceProvider {
  43    public interface ServiceSocketHandlerFactory {
  44
  45       public Runnable create(Socket aSocket) ;
  46
  47    }
  48    private final JxtaNetworkManager mJxtaNetworkManager;
  49    private final Configurator mProperties;
  50    private final  String SERVICE_PIPE_ID;
  51    private final static Logger mLog = Logger.getLogger(GenericService.class);
  52    private final  String ADV_NAME ;
  53    private final  String MODULE_CLASS_ID;
  54    private final  String MODULE_SPEC_ID;
  55    private JxtaServerSocket mJxtaServerSocket;
  56    private final String mServiceName;
  57    private Thread mSocketServerThread ;
  58    private final ExecutorService mPool;
  59    private final ServiceSocketHandlerFactory mServiceSocketHandlerFactory;
  60    private boolean mExist = false;
  61
  62    public GenericService(Configurator lProperties,JxtaNetworkManager aJxtaNetworkManager,String aServiceName,ServiceSocketHandlerFactory aServiceSocketHandlerFactory) {
  63        mJxtaNetworkManager = aJxtaNetworkManager;
  64        mProperties = lProperties;
  65        mServiceName = aServiceName.trim();
  66        SERVICE_PIPE_ID="org.linphone.p2pproxy."+mServiceName+".bidi-pipe.id";
  67        ADV_NAME = "JXTASPEC:LINPHONE-"+mServiceName;
  68        MODULE_CLASS_ID="org.linphone.p2pproxy."+mServiceName+"Service.module-class.id";
  69        MODULE_SPEC_ID="org.linphone.p2pproxy."+mServiceName+"Service.module-spec.id";
  70        mSocketServerThread = new Thread(this,mServiceName+"Service server thread");
  71        mPool = Executors.newCachedThreadPool();
  72        mServiceSocketHandlerFactory = aServiceSocketHandlerFactory;
  73    }
  74
  75    public void start(long l)  throws P2pProxyException {
  76       try {
  77          mLog.info("Start the RtpRelayService daemon");
  78          ModuleClassAdvertisement lModuleAdvertisement = (ModuleClassAdvertisement) AdvertisementFactory.newAdvertisement(ModuleClassAdvertisement.getAdvertisementType());
  79
  80          lModuleAdvertisement.setName("JXTAMOD:LINPHONE-"+mServiceName);
  81          lModuleAdvertisement.setDescription("Service to provide " +mServiceName);
  82
  83          ModuleClassID lModuleClassID;
  84          // to avoid ID creation at each start
  85          if (mProperties.getProperty(MODULE_CLASS_ID) == null) {
  86             lModuleClassID = IDFactory.newModuleClassID();
  87             mProperties.setProperty(MODULE_CLASS_ID, lModuleClassID.toURI().toString());
  88          } else {
  89             lModuleClassID = (ModuleClassID) IDFactory.fromURI(URI.create(mProperties.getProperty(MODULE_CLASS_ID)));
  90          }
  91          lModuleAdvertisement.setModuleClassID(lModuleClassID);
  92
  93          // publish local only
  94          mJxtaNetworkManager.getPeerGroup().getDiscoveryService().publish(lModuleAdvertisement);
  95
  96          ModuleSpecAdvertisement lModuleSpecAdvertisement = (ModuleSpecAdvertisement)AdvertisementFactory.newAdvertisement(ModuleSpecAdvertisement.getAdvertisementType());
  97          lModuleSpecAdvertisement.setName(ADV_NAME);
  98          lModuleSpecAdvertisement.setVersion("Version 1.0");
  99          lModuleSpecAdvertisement.setCreator("linphone.org");
 100          // to avoid ID creation at each start
 101          ModuleSpecID  lModuleSpecId;
 102          if (mProperties.getProperty(MODULE_SPEC_ID) == null) {
 103             lModuleSpecId = IDFactory.newModuleSpecID(lModuleClassID);
 104             mProperties.setProperty(MODULE_SPEC_ID, lModuleSpecId.toURI().toString());
 105          } else {
 106             lModuleSpecId = (ModuleSpecID) IDFactory.fromURI(URI.create(mProperties.getProperty(MODULE_SPEC_ID)));
 107          }
 108          lModuleSpecAdvertisement.setModuleSpecID(lModuleSpecId);
 109          lModuleSpecAdvertisement.setSpecURI("http://www.linphone.org/"+mServiceName.toLowerCase());
 110
 111          PipeAdvertisement lSocketAdvertisement = mJxtaNetworkManager.createPipeAdvertisement(SERVICE_PIPE_ID, mServiceName.toLowerCase());
 112
 113          lModuleSpecAdvertisement.setPipeAdvertisement(lSocketAdvertisement);
 114          mJxtaServerSocket = new JxtaServerSocket(mJxtaNetworkManager.getPeerGroup(), lSocketAdvertisement, 10);
 115          mJxtaServerSocket.setSoTimeout(0);
 116          mSocketServerThread.start();
 117          //publish local only
 118          mJxtaNetworkManager.getPeerGroup().getDiscoveryService().publish(lModuleSpecAdvertisement);
 119          mLog.info("Adv ["+lModuleSpecAdvertisement+"] published");
 120       }
 121       catch(Exception e)
 122       {
 123          mLog.error("socket instance error", e);
 124       }
 125    }
 126    public void stop(){
 127            try {
 128                 mJxtaServerSocket.close();
 129         } catch (IOException e) {
 130                 //nop
 131         }
 132            mExist = true;
 133    }
 134    public void run() {
 135       while (mExist) {
 136          try {
 137             mLog.info("Waiting for connection on service ["+ADV_NAME+"]");
 138              Socket lSocket = mJxtaServerSocket.accept();
 139              // set reliable
 140              if (lSocket != null) {
 141                 mLog.info("socket created");
 142                 mPool.execute(mServiceSocketHandlerFactory.create(lSocket));
 143              }
 144          } catch (Exception e) {
 145             mLog.error("Server socket  error",e);
 146          }
 147      }
 148
 149    }
 150
 151    /**
 152     * @return Returns the aDV_NAME.
 153     */
 154    public String getAdvName() {
 155       return ADV_NAME;
 156    }
 157 }