bgpmanager/bgpmanager-impl/src/main/java/org/opendaylight/bgpmanager/thrift/server/implementation/BgpThriftService.java

   1 package org.opendaylight.bgpmanager.thrift.server.implementation;
   2
   3 import org.apache.thrift.server.THsHaServer;
   4 import org.apache.thrift.server.TServer;
   5 import org.apache.thrift.server.TSimpleServer;
   6 import org.apache.thrift.server.TThreadPoolServer;
   7 import org.apache.thrift.transport.*;
   8 import org.opendaylight.bgpmanager.BgpManager;
   9 import org.opendaylight.bgpmanager.FibDSWriter;
  10 import org.opendaylight.bgpmanager.thrift.common.Constants;
  11 import org.opendaylight.bgpmanager.thrift.gen.BgpUpdater;
  12 import org.slf4j.Logger;
  13 import org.slf4j.LoggerFactory;
  14
  15 public class BgpThriftService {
  16
  17         private static final Logger logger = LoggerFactory.getLogger(BgpThriftService.class);
  18
  19         private int port;
  20         //private int serverType;
  21         private int maxWorkerThreads;
  22         private int minWorkerThreads;
  23     private TServerTransport serverTransport;
  24         //private TNonblockingServerTransport serverTransport;
  25     private TServer server;
  26         private BgpUpdateHandler notificationHandler;
  27         private BgpManager bgpManager;
  28
  29     public BgpThriftService(BgpManager bgpMgr, FibDSWriter dsWriter) {
  30         bgpManager = bgpMgr;
  31                 notificationHandler = new BgpUpdateHandler(bgpManager, dsWriter);
  32                 //fibDSWriter = dsWriter;
  33     }
  34
  35
  36         public void start() {
  37                 logger.info("BGP Thrift Server starting.");
  38                 startBgpThriftServer();
  39         }
  40
  41         public void stop() {
  42                 logger.info("BGP Thrift Server stopping.");
  43                 stopBgpThriftServer();
  44         }
  45
  46         /**
  47          * Destroy method called up after the bundle has been stopped
  48          */
  49         public void destroy() {
  50                 logger.debug("BGP Thrift Server destroy ");
  51         }
  52
  53     /**
  54      * Loading the parameters required for a connection
  55      *
  56      */
  57     private void loadParameters() {
  58         port = Integer.getInteger(Constants.PROP_BGP_THRIFT_PORT, Constants.BGP_SERVICE_PORT);
  59                 maxWorkerThreads = Integer.getInteger(Constants.PROP_MAX_WORKER_THREADS,
  60                         Constants.DEFAULT_MAX_WORKER_THREADS);
  61                 minWorkerThreads = Integer.getInteger(Constants.PROP_MIN_WORKER_THREADS,
  62                         Constants.DEFAULT_MIN_WORKER_THREADS);
  63
  64         }
  65
  66
  67         public void startBgpThriftServer() {
  68                 loadParameters();
  69                 new Thread(new ThriftRunnable()).start();
  70         }
  71
  72         public void stopBgpThriftServer() {
  73                 try {
  74             logger.debug("Server stopping");
  75
  76             if (serverTransport != null) {
  77                 serverTransport.close();
  78             }
  79
  80             server.stop();
  81         } catch (Exception e) {
  82             logger.error("Error while stopping the server - {} {}", getClass().getName(), e.getMessage());
  83         }
  84         }
  85
  86         private class ThriftRunnable implements Runnable {
  87                 @Override
  88                 public void run() {
  89                         //notificationHandler = new BgpUpdateHandler(bgpManager);
  90
  91                 try {
  92                                 serverTransport = new TServerSocket(port);
  93                                 //serverTransport = new TNonblockingServerSocket(port);
  94                     logger.info("Server Socket on Port {} ", port);
  95                         } catch (TTransportException e) {
  96                                 e.printStackTrace();
  97                                 return;
  98                         }
  99                         /* This may need to change. Right now, its as good as a blocking server for each client (client would be
 100                         single - qbgp). We may want to change the server to TSimpleServer which queues up the notifications and
 101                         let worker threads process notifications based on rd.
 102                          */
 103                 server = new TThreadPoolServer(new TThreadPoolServer.Args(serverTransport)
 104                         .maxWorkerThreads(maxWorkerThreads).minWorkerThreads(minWorkerThreads)
 105                         .processor(new BgpUpdater.Processor<BgpUpdateHandler>(notificationHandler)));
 106                         /*
 107                         THsHaServer.Args args = new THsHaServer.Args(serverTransport);
 108                         args.workerThreads(10);
 109                         server = new THsHaServer(args.processor(new BgpUpdater.Processor<BgpUpdateHandler>(notificationHandler)));*/
 110
 111                         server.serve();
 112                 }
 113         }
 114
 115 }